diff --git a/BUILD.gn b/BUILD.gn index eb9d270c679..12c2257204c 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -142,6 +142,7 @@ vvl_sources = [ "layers/error_message/logging.cpp", "layers/error_message/logging.h", "layers/error_message/record_object.h", + "layers/error_message/log_message_type.h", "layers/external/inplace_function.h", "layers/external/vma/vk_mem_alloc.h", "layers/external/vma/vma.cpp", diff --git a/README.md b/README.md index 29160a7cae4..034ed8bc599 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,10 @@ For those who don't want to build from source, there are few ways to get working - For Android, each SDK tag will have binaries to download (example: [vulkan-sdk-1.3.280.0 tag](https://github.com/KhronosGroup/Vulkan-ValidationLayers/releases/tag/vulkan-sdk-1.3.280.0)) - Every change applied to the main branch runs through GitHub action and will [produce artifacts](https://github.com/KhronosGroup/Vulkan-ValidationLayers/actions?query=branch%3Amain) of the latest commit. +## Adjusting settings + +See [settings documentation](./docs/settings.md). + ## Community Assistance Before submitting an issue to the validation layers or reaching out to the developers it may be prudent to reach out to the community first. diff --git a/docs/settings.md b/docs/settings.md new file mode 100644 index 00000000000..891f38b134a --- /dev/null +++ b/docs/settings.md @@ -0,0 +1,78 @@ +# Settings + +There are many settings that can be set for Validation layers. This is a brief overview of how to use them. + +There are 4 ways to configure the settings: `vkconfig`, `application defined`, `vk_layer_settings.txt`, `environment variables` + +## VkConfig + +We suggest people to use [VkConfig](https://www.lunarg.com/introducing-the-new-vulkan-configurator-vkconfig/). + +The GUI comes with the SDK, and takes the `VkLayer_khronos_validation.json` file and does **everything** for you! + +## Application Defined + +The application can now use the `VK_EXT_layer_settings` extension to do everything at `vkCreateInstance` time. (Don't worry, we implement the extension, so it will be supported 100% of the time!). + +```c++ +// Example how to turn on verbose mode for DebugPrintf +const VkBool32 verbose_value = true; +const VkLayerSettingEXT layer_setting = {"VK_LAYER_KHRONOS_validation", "printf_verbose", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &verbose_value}; +VkLayerSettingsCreateInfoEXT layer_settings_create_info = {VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, nullptr, 1, &layer_setting}; + +VkInstanceCreateInfo instance_ci = GetYourCreateInfo(); +instance_ci.pNext = &layer_settings_create_info; +``` + +## vk_layer_settings.txt + +There is info [elsewhere](https://vulkan.lunarg.com/doc/view/latest/windows/layer_configuration.html) to describe this file, but the short answer is to set the `VK_LAYER_SETTINGS_PATH` like the following: + +``` +# windows +set VK_LAYER_SETTINGS_PATH=C:\path\to\vk_layer_settings.txt + +# linux +export VK_LAYER_SETTINGS_PATH=/path/to/vk_layer_settings.txt +``` + +and it will set things for you in that file. We have a [default example](../layers/vk_layer_settings.txt) file you can start with. + +## Environment Variables + +This is done for us via the `vkuCreateLayerSettingSet` call in the [Vulkan-Utility-Libraries](https://github.com/KhronosGroup/Vulkan-Utility-Libraries/). + +As an example, in our `VkLayer_khronos_validation.json` file you will find something like `"key": "message_id_filter",`. + +From here you just need to adjust it the naming and prefix depending on your platform: + +``` +# Windows +set VK_LAYER_MESSAGE_ID_FILTER=VUID-VkInstanceCreateInfo-pNext-pNext + +# Linux +export VK_LAYER_MESSAGE_ID_FILTER=VUID-VkInstanceCreateInfo-pNext-pNext + +# Android +adb setprop debug.vulkan.khronos_validation.message_id_filter=VUID-VkInstanceCreateInfo-pNext-pNext +``` + +## Finding available settings + +How we suggest finding them: + +1. Check VkConfig +2. View `VkLayer_khronos_validation.json` (it is where we define them all) +3. In [layer_options.cpp](../layers/layer_options.cpp) (it is where we parse and set the settings) + +## Legacy + +This is only here to document the legacy of how we got to this situation. + +Long ago validation created its own system to parse environmental variables as well as the `vk_layer_settings.txt` flow. + +Then we created `VK_EXT_validation_features` as way to set things at `vkCreateInstance` time. `VK_EXT_validation_flags` was also created after with the same goals in mind. + +As more and more layers basically needed to do what Validation Layers were doing, we just ended up creating `VK_EXT_layer_settings` as a final solution. This extension has been the way forward to a better system of creating settings for layers. + +Unfortunately, we still support some legacy names, so this prevents us from making everything consistent. \ No newline at end of file diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt index 91afeb8768e..d4e706b4c98 100644 --- a/layers/CMakeLists.txt +++ b/layers/CMakeLists.txt @@ -29,6 +29,7 @@ target_sources(VkLayer_utils PRIVATE error_message/error_location.h error_message/error_strings.h error_message/record_object.h + error_message/log_message_type.h external/xxhash.h external/inplace_function.h ${API_TYPE}/generated/error_location_helper.cpp diff --git a/layers/error_message/log_message_type.h b/layers/error_message/log_message_type.h new file mode 100644 index 00000000000..c356a225389 --- /dev/null +++ b/layers/error_message/log_message_type.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2015-2024 The Khronos Group Inc. + * Copyright (c) 2015-2024 Valve Corporation + * Copyright (c) 2015-2024 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#pragma once + +#include + +// These aim to follow VkDebugReportFlagBitsEXT but were created prior +// Could replace with VkDebugReportFlagBitsEXT, but would be a LOT of churn and these +// names are less verbose and desired. +enum LogMessageTypeBits { + kInformationBit = 0x00000001, + kWarningBit = 0x00000002, + kPerformanceWarningBit = 0x00000004, + kErrorBit = 0x00000008, + kVerboseBit = 0x00000010, +}; +using LogMessageTypeFlags = VkFlags; \ No newline at end of file diff --git a/layers/error_message/logging.cpp b/layers/error_message/logging.cpp index 2950913e67f..a8f20f258b3 100644 --- a/layers/error_message/logging.cpp +++ b/layers/error_message/logging.cpp @@ -676,6 +676,49 @@ VKAPI_ATTR VkBool32 VKAPI_CALL MessengerBreakCallback([[maybe_unused]] VkDebugUt return false; } +static void PrintMessageSeverity(VkFlags vk_flags, char *msg_flags) { + bool separator = false; + + msg_flags[0] = 0; + if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) { + strcat(msg_flags, "VERBOSE"); + separator = true; + } + if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) { + if (separator) strcat(msg_flags, ","); + strcat(msg_flags, "INFO"); + separator = true; + } + if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { + if (separator) strcat(msg_flags, ","); + strcat(msg_flags, "WARN"); + separator = true; + } + if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { + if (separator) strcat(msg_flags, ","); + strcat(msg_flags, "ERROR"); + } +} + +static void PrintMessageType(VkFlags vk_flags, char *msg_flags) { + bool separator = false; + + msg_flags[0] = 0; + if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) { + strcat(msg_flags, "GEN"); + separator = true; + } + if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) { + if (separator) strcat(msg_flags, ","); + strcat(msg_flags, "SPEC"); + separator = true; + } + if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) { + if (separator) strcat(msg_flags, ","); + strcat(msg_flags, "PERF"); + } +} + VKAPI_ATTR VkBool32 VKAPI_CALL MessengerLogCallback(VkDebugUtilsMessageSeverityFlagBitsEXT message_severity, VkDebugUtilsMessageTypeFlagsEXT message_type, const VkDebugUtilsMessengerCallbackDataEXT *callback_data, void *user_data) { diff --git a/layers/error_message/logging.h b/layers/error_message/logging.h index 6e43c3e7122..944c8ec9ddf 100644 --- a/layers/error_message/logging.h +++ b/layers/error_message/logging.h @@ -26,7 +26,7 @@ #include -#include "vk_layer_config.h" +#include "error_message/log_message_type.h" #include "containers/custom_containers.h" #include "generated/vk_layer_dispatch_table.h" #include "generated/vk_object_types.h" diff --git a/layers/gpu/debug_printf/debug_printf.cpp b/layers/gpu/debug_printf/debug_printf.cpp index 4d6aab83d29..32654a969a2 100644 --- a/layers/gpu/debug_printf/debug_printf.cpp +++ b/layers/gpu/debug_printf/debug_printf.cpp @@ -19,6 +19,7 @@ #include "generated/layer_chassis_dispatch.h" #include "chassis/chassis_modification_state.h" #include "gpu/shaders/gpu_error_header.h" +#include "vk_layer_config.h" #include diff --git a/layers/layer_options.cpp b/layers/layer_options.cpp index 6f52b7fce9b..bb60b491182 100644 --- a/layers/layer_options.cpp +++ b/layers/layer_options.cpp @@ -204,6 +204,10 @@ const char *VK_LAYER_SYNCVAL_SHADER_ACCESSES_HEURISTIC = "syncval_shader_accesse // Message Formatting // --- const char *VK_LAYER_MESSAGE_FORMAT_DISPLAY_APPLICATION_NAME = "message_format_display_application_name"; +// Until post 1.3.290 SDK release, these were not possible to set via environment variables +const char *VK_LAYER_LOG_FILENAME = "log_filename"; +const char *VK_LAYER_DEBUG_ACTION = "debug_action"; +const char *VK_LAYER_REPORT_FLAGS = "report_flags"; // These were deprecated after the 1.3.280 SDK release const char *DEPRECATED_VK_LAYER_GPUAV_VALIDATE_COPIES = "gpuav_validate_copies"; @@ -442,8 +446,12 @@ void CreateFilterMessageIdList(std::string raw_id_list, const std::string &delim // Because VkLayerSettingsCreateInfoEXT/VkLayerSettingEXT are passed in and used before everything else, need to do the stateless // validation here as a special exception // +// We want to use the DebugReport object to print VU error messages in here, but we need to parse the settings in +// VkLayerSettingsCreateInfoEXT in order to configure the DebugReport object. Therefor we just settle with printf in here. These are +// very unlikely things to hit validation layers messages (as everything after will likely crumble) so should be ok. +// // Returns if valid -static bool ValidateLayerSettings(const VkLayerSettingsCreateInfoEXT *layer_settings, DebugReport *debug_report) { +static bool ValidateLayerSettings(const VkLayerSettingsCreateInfoEXT *layer_settings) { bool valid = true; if (!layer_settings) return valid; const Location loc(vvl::Func::vkCreateInstance, vvl::Field::pCreateInfo); @@ -454,24 +462,28 @@ static bool ValidateLayerSettings(const VkLayerSettingsCreateInfoEXT *layer_sett for (const auto [i, setting] : vvl::enumerate(layer_settings->pSettings, layer_settings->settingCount)) { const Location setting_loc = create_info_loc.dot(vvl::Field::pSettings, i); if (setting->valueCount > 0 && !setting->pValues) { - ss << setting_loc.dot(vvl::Field::pValues).Message() << " is NULL"; - debug_report->DebugLogMsg(kErrorBit, {}, ss.str().c_str(), "VUID-VkLayerSettingEXT-valueCount-10070"); + ss << "[ VUID-VkLayerSettingEXT-valueCount-10070 ] " << setting_loc.dot(vvl::Field::pValues).Message() + << " is NULL"; + printf("Validation Layer Error: %s\n", ss.str().c_str()); valid = false; } if (!setting->pLayerName) { - ss << setting_loc.dot(vvl::Field::pLayerName).Message() << " is NULL"; - debug_report->DebugLogMsg(kErrorBit, {}, ss.str().c_str(), "VUID-VkLayerSettingEXT-pLayerName-parameter"); + ss << "[ VUID-VkLayerSettingEXT-pLayerName-parameter ] " << setting_loc.dot(vvl::Field::pLayerName).Message() + << " is NULL"; + printf("Validation Layer Error: %s\n", ss.str().c_str()); valid = false; } if (!setting->pSettingName) { - ss << setting_loc.dot(vvl::Field::pSettingName).Message() << " is NULL"; - debug_report->DebugLogMsg(kErrorBit, {}, ss.str().c_str(), "VUID-VkLayerSettingEXT-pSettingName-parameter"); + ss << "[ VUID-VkLayerSettingEXT-pSettingName-parameter ] " << setting_loc.dot(vvl::Field::pSettingName).Message() + << " is NULL"; + printf("Validation Layer Error: %s\n", ss.str().c_str()); valid = false; } } } else if (layer_settings->settingCount > 0) { - ss << create_info_loc.dot(vvl::Field::pSettings).Message() << " is NULL"; - debug_report->DebugLogMsg(kErrorBit, {}, ss.str().c_str(), "VUID-VkLayerSettingsCreateInfoEXT-pSettings-parameter"); + ss << "[ VUID-VkLayerSettingsCreateInfoEXT-pSettings-parameter ] " << create_info_loc.dot(vvl::Field::pSettings).Message() + << " is NULL"; + printf("Validation Layer Error: %s\n", ss.str().c_str()); valid = false; } return valid; @@ -508,6 +520,167 @@ static std::string Merge(const std::vector &strings) { return result; } +// If option is NULL or stdout, return stdout, otherwise try to open option +// as a filename. If successful, return file handle, otherwise stdout +FILE *GetLayerLogOutput(const char *option) { + FILE *log_output = NULL; + if (!option || !strcmp("stdout", option)) { + log_output = stdout; + } else { + log_output = fopen(option, "w"); + if (log_output == NULL) { + if (option) { + printf("Validation Layers Error: Bad output filename specified: %s. Writing to STDOUT instead\n", option); + } + log_output = stdout; + } + } + return log_output; +} + +// Definitions for Debug Actions +enum VkLayerDbgActionBits { + VK_DBG_LAYER_ACTION_IGNORE = 0x00000000, + VK_DBG_LAYER_ACTION_CALLBACK = 0x00000001, + VK_DBG_LAYER_ACTION_LOG_MSG = 0x00000002, + VK_DBG_LAYER_ACTION_BREAK = 0x00000004, + VK_DBG_LAYER_ACTION_DEBUG_OUTPUT = 0x00000008, + VK_DBG_LAYER_ACTION_DEFAULT = 0x40000000, +}; +using VkLayerDbgActionFlags = VkFlags; + +static void ProcessDebugReportSettings(DebugReport *debug_report, VkuLayerSettingSet &layer_setting_set) { + // Message ID Filtering + std::vector message_id_filter; + if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_MESSAGE_ID_FILTER)) { + vkuGetLayerSettingValues(layer_setting_set, VK_LAYER_MESSAGE_ID_FILTER, message_id_filter); + } + const std::string string_message_id_filter = Merge(message_id_filter); + CreateFilterMessageIdList(string_message_id_filter, ",", debug_report->filter_message_ids); + + // Duplicate message limit + if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_DUPLICATE_MESSAGE_LIMIT)) { + uint32_t config_limit_setting = 0; + vkuGetLayerSettingValue(layer_setting_set, VK_LAYER_DUPLICATE_MESSAGE_LIMIT, config_limit_setting); + if (config_limit_setting != 0) { + debug_report->duplicate_message_limit = config_limit_setting; + } + } + + if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_MESSAGE_FORMAT_DISPLAY_APPLICATION_NAME)) { + vkuGetLayerSettingValue(layer_setting_set, VK_LAYER_MESSAGE_FORMAT_DISPLAY_APPLICATION_NAME, + debug_report->message_format_settings.display_application_name); + } + + std::string log_filename = "stdout"; // Default + if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_LOG_FILENAME)) { + vkuGetLayerSettingValue(layer_setting_set, VK_LAYER_LOG_FILENAME, log_filename); + } + const bool is_stdout = log_filename.compare("stdout") == 0; + + // Default + std::vector debug_actions_list = {"VK_DBG_LAYER_ACTION_DEFAULT", "VK_DBG_LAYER_ACTION_LOG_MSG"}; +#ifdef WIN32 + // For Windows, enable message logging AND OutputDebugString + debug_actions_list.push_back("VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"); +#endif // WIN32 + + if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_DEBUG_ACTION)) { + vkuGetLayerSettingValues(layer_setting_set, VK_LAYER_DEBUG_ACTION, debug_actions_list); + } + + VkLayerDbgActionFlags debug_action = 0; + const vvl::unordered_map debug_actions_option = { + {std::string("VK_DBG_LAYER_ACTION_IGNORE"), VK_DBG_LAYER_ACTION_IGNORE}, + {std::string("VK_DBG_LAYER_ACTION_CALLBACK"), VK_DBG_LAYER_ACTION_CALLBACK}, + {std::string("VK_DBG_LAYER_ACTION_LOG_MSG"), VK_DBG_LAYER_ACTION_LOG_MSG}, + {std::string("VK_DBG_LAYER_ACTION_BREAK"), VK_DBG_LAYER_ACTION_BREAK}, + {std::string("VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"), VK_DBG_LAYER_ACTION_DEBUG_OUTPUT}, + {std::string("VK_DBG_LAYER_ACTION_DEFAULT"), VK_DBG_LAYER_ACTION_DEFAULT}}; + for (const auto &element : debug_actions_list) { + auto enum_value = debug_actions_option.find(element); + if (enum_value != debug_actions_option.end()) { + debug_action |= enum_value->second; + } else { + printf("Validation Layer Warning - %s was is not a valid option for VK_LAYER_DEBUG_ACTION (ignoring).\n", + element.c_str()); + } + } + + std::vector report_flags_list = {"error"}; // Default + if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_REPORT_FLAGS)) { + vkuGetLayerSettingValues(layer_setting_set, VK_LAYER_REPORT_FLAGS, report_flags_list); + } + + VkLayerDbgActionFlags report_flags = 0; + const vvl::unordered_map report_flags_options = {{std::string("warn"), kWarningBit}, + {std::string("info"), kInformationBit}, + {std::string("perf"), kPerformanceWarningBit}, + {std::string("error"), kErrorBit}, + {std::string("verbose"), kVerboseBit}}; + for (const auto &element : report_flags_list) { + auto enum_value = report_flags_options.find(element); + if (enum_value != report_flags_options.end()) { + report_flags |= enum_value->second; + } else { + printf("Validation Layer Warning - %s was is not a valid option for VK_LAYER_REPORT_FLAGS (ignoring).\n", + element.c_str()); + } + } + + // Flag as default if these settings are not from a vk_layer_settings.txt file + const bool default_layer_callback = (debug_action & VK_DBG_LAYER_ACTION_DEFAULT) != 0; + + VkDebugUtilsMessengerCreateInfoEXT dbg_create_info = vku::InitStructHelper(); + dbg_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT; + if (report_flags & kErrorBit) { + dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + } + if (report_flags & kWarningBit) { + dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; + } + if (report_flags & kPerformanceWarningBit) { + dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; + dbg_create_info.messageType |= VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; + } + if (report_flags & kInformationBit) { + dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; + } + if (report_flags & kVerboseBit) { + dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; + } + + VkDebugUtilsMessengerEXT messenger = VK_NULL_HANDLE; + if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) { + FILE *log_output = GetLayerLogOutput(log_filename.c_str()); + if (log_output != stdout) { + printf("Validation Layer Info - Logging validation error to %s\n", log_filename.c_str()); + } + dbg_create_info.pfnUserCallback = MessengerLogCallback; + dbg_create_info.pUserData = (void *)log_output; + LayerCreateMessengerCallback(debug_report, default_layer_callback, &dbg_create_info, &messenger); + } else if (!is_stdout) { + printf( + "Validation Layer Warning - You have log_filename set to %s but VK_DBG_LAYER_ACTION_LOG_MSG was not set, so it won't " + "be sent to the file\n", + log_filename.c_str()); + } + + messenger = VK_NULL_HANDLE; + if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) { + dbg_create_info.pfnUserCallback = MessengerWin32DebugOutputMsg; + dbg_create_info.pUserData = nullptr; + LayerCreateMessengerCallback(debug_report, default_layer_callback, &dbg_create_info, &messenger); + } + + messenger = VK_NULL_HANDLE; + if (debug_action & VK_DBG_LAYER_ACTION_BREAK) { + dbg_create_info.pfnUserCallback = MessengerBreakCallback; + dbg_create_info.pUserData = nullptr; + LayerCreateMessengerCallback(debug_report, default_layer_callback, &dbg_create_info, &messenger); + } +} + static const char *GetDefaultPrefix() { #ifdef __ANDROID__ return "vvl"; @@ -523,7 +696,23 @@ void ProcessConfigAndEnvSettings(ConfigAndEnvSettings *settings_data) { // so that the layer always defaults to the standard validation options we want, // and does not try to process option coming from the VVL we are debugging #if defined(BUILD_SELF_VVL) - (void)settings_data; + // Setup default messenger callback to stdout and just error validaiton messages + FILE *log_output = stdout; + VkDebugUtilsMessengerEXT messenger = VK_NULL_HANDLE; + VkDebugUtilsMessengerCreateInfoEXT dbg_create_info = vku::InitStructHelper(); + dbg_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT; + dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + dbg_create_info.pfnUserCallback = MessengerLogCallback; + dbg_create_info.pUserData = (void *)log_output; + LayerCreateMessengerCallback(settings_data->debug_report, true, &dbg_create_info, &messenger); + +#ifdef WIN32 + messenger = VK_NULL_HANDLE; + dbg_create_info.pfnUserCallback = MessengerWin32DebugOutputMsg; + dbg_create_info.pUserData = nullptr; + LayerCreateMessengerCallback(settings_data->debug_report, true, &dbg_create_info, &messenger); +#endif // WIN32 + return; #else // If not cleared, garbage has been seen in some Android run effecting the error message @@ -531,7 +720,7 @@ void ProcessConfigAndEnvSettings(ConfigAndEnvSettings *settings_data) { VkuLayerSettingSet layer_setting_set = VK_NULL_HANDLE; auto layer_setting_create_info = vkuFindLayerSettingsCreateInfo(settings_data->create_info); - if (!ValidateLayerSettings(layer_setting_create_info, settings_data->debug_report)) { + if (!ValidateLayerSettings(layer_setting_create_info)) { return; // nullptr will crash things } vkuCreateLayerSettingSet(OBJECT_LAYER_NAME, layer_setting_create_info, nullptr, nullptr, &layer_setting_set); @@ -563,23 +752,6 @@ void ProcessConfigAndEnvSettings(ConfigAndEnvSettings *settings_data) { vkuGetLayerSettingValue(layer_setting_set, VK_LAYER_DEBUG_DISABLE_SPIRV_VAL, global_settings.debug_disable_spirv_val); } - // Message ID Filtering - std::vector message_id_filter; - if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_MESSAGE_ID_FILTER)) { - vkuGetLayerSettingValues(layer_setting_set, VK_LAYER_MESSAGE_ID_FILTER, message_id_filter); - } - const std::string string_message_id_filter = Merge(message_id_filter); - CreateFilterMessageIdList(string_message_id_filter, ",", settings_data->debug_report->filter_message_ids); - - // Duplicate message limit - if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_DUPLICATE_MESSAGE_LIMIT)) { - uint32_t config_limit_setting = 0; - vkuGetLayerSettingValue(layer_setting_set, VK_LAYER_DUPLICATE_MESSAGE_LIMIT, config_limit_setting); - if (config_limit_setting != 0) { - settings_data->debug_report->duplicate_message_limit = config_limit_setting; - } - } - if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_CUSTOM_STYPE_LIST)) { vkuGetLayerSettingValues(layer_setting_set, VK_LAYER_CUSTOM_STYPE_LIST, GetCustomStypeInfo()); } @@ -756,10 +928,8 @@ void ProcessConfigAndEnvSettings(ConfigAndEnvSettings *settings_data) { syncval_settings.shader_accesses_heuristic); } - if (vkuHasLayerSetting(layer_setting_set, VK_LAYER_MESSAGE_FORMAT_DISPLAY_APPLICATION_NAME)) { - vkuGetLayerSettingValue(layer_setting_set, VK_LAYER_MESSAGE_FORMAT_DISPLAY_APPLICATION_NAME, - settings_data->debug_report->message_format_settings.display_application_name); - } + ProcessDebugReportSettings(settings_data->debug_report, layer_setting_set); + // Grab application name here while we have access to it and know if to save it or not if (settings_data->debug_report->message_format_settings.display_application_name) { settings_data->debug_report->message_format_settings.application_name = diff --git a/layers/sync/sync_validation.cpp b/layers/sync/sync_validation.cpp index 8fa749ca9a1..a7bfea4efb4 100644 --- a/layers/sync/sync_validation.cpp +++ b/layers/sync/sync_validation.cpp @@ -26,6 +26,7 @@ #include "state_tracker/device_state.h" #include "state_tracker/buffer_state.h" #include "utils/convert_utils.h" +#include "vk_layer_config.h" SyncValidator::~SyncValidator() { // Instance level SyncValidator does not have much to say diff --git a/layers/utils/vk_layer_utils.cpp b/layers/utils/vk_layer_utils.cpp index 1b5b6cc3730..2d79c446d67 100644 --- a/layers/utils/vk_layer_utils.cpp +++ b/layers/utils/vk_layer_utils.cpp @@ -21,92 +21,8 @@ #include #include "containers/range_vector.h" -#include "vulkan/vulkan.h" - -// Debug callbacks get created in three ways: -// o Application-defined debug callbacks -// o Through settings in a vk_layer_settings.txt file -// o By default, if neither an app-defined debug callback nor a vk_layer_settings.txt file is present -// -// At layer initialization time, default logging callbacks are created to output layer error messages. -// If a vk_layer_settings.txt file is present its settings will override any default settings. -// -// If a vk_layer_settings.txt file is present and an application defines a debug callback, both callbacks -// will be active. If no vk_layer_settings.txt file is present, creating an application-defined debug -// callback will cause the default callbacks to be unregisterd and removed. -void LayerDebugMessengerActions(DebugReport *debug_report, const char *layer_identifier) { - VkDebugUtilsMessengerEXT messenger = VK_NULL_HANDLE; - - std::string report_flags_key = layer_identifier; - std::string debug_action_key = layer_identifier; - std::string log_filename_key = layer_identifier; - report_flags_key.append(".report_flags"); - debug_action_key.append(".debug_action"); - log_filename_key.append(".log_filename"); - - const vvl::unordered_map debug_actions_option_definitions = { - {std::string("VK_DBG_LAYER_ACTION_IGNORE"), VK_DBG_LAYER_ACTION_IGNORE}, - {std::string("VK_DBG_LAYER_ACTION_CALLBACK"), VK_DBG_LAYER_ACTION_CALLBACK}, - {std::string("VK_DBG_LAYER_ACTION_LOG_MSG"), VK_DBG_LAYER_ACTION_LOG_MSG}, - {std::string("VK_DBG_LAYER_ACTION_BREAK"), VK_DBG_LAYER_ACTION_BREAK}, - {std::string("VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"), VK_DBG_LAYER_ACTION_DEBUG_OUTPUT}, - {std::string("VK_DBG_LAYER_ACTION_DEFAULT"), VK_DBG_LAYER_ACTION_DEFAULT}}; - - const vvl::unordered_map log_msg_type_option_definitions = {{std::string("warn"), kWarningBit}, - {std::string("info"), kInformationBit}, - {std::string("perf"), kPerformanceWarningBit}, - {std::string("error"), kErrorBit}, - {std::string("verbose"), kVerboseBit}}; - - // Initialize layer options - LogMessageTypeFlags report_flags = GetLayerOptionFlags(report_flags_key, log_msg_type_option_definitions, 0); - VkLayerDbgActionFlags debug_action = GetLayerOptionFlags(debug_action_key, debug_actions_option_definitions, 0); - // Flag as default if these settings are not from a vk_layer_settings.txt file - const bool default_layer_callback = (debug_action & VK_DBG_LAYER_ACTION_DEFAULT) != 0; - - VkDebugUtilsMessengerCreateInfoEXT dbg_create_info = vku::InitStructHelper(); - dbg_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT; - if (report_flags & kErrorBit) { - dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; - } - if (report_flags & kWarningBit) { - dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - } - if (report_flags & kPerformanceWarningBit) { - dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; - dbg_create_info.messageType |= VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; - } - if (report_flags & kInformationBit) { - dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT; - } - if (report_flags & kVerboseBit) { - dbg_create_info.messageSeverity |= VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT; - } - - if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) { - const char *log_filename = getLayerOption(log_filename_key.c_str()); - FILE *log_output = getLayerLogOutput(log_filename, layer_identifier); - dbg_create_info.pfnUserCallback = MessengerLogCallback; - dbg_create_info.pUserData = (void *)log_output; - LayerCreateMessengerCallback(debug_report, default_layer_callback, &dbg_create_info, &messenger); - } - - messenger = VK_NULL_HANDLE; - - if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) { - dbg_create_info.pfnUserCallback = MessengerWin32DebugOutputMsg; - dbg_create_info.pUserData = NULL; - LayerCreateMessengerCallback(debug_report, default_layer_callback, &dbg_create_info, &messenger); - } - - messenger = VK_NULL_HANDLE; - - if (debug_action & VK_DBG_LAYER_ACTION_BREAK) { - dbg_create_info.pfnUserCallback = MessengerBreakCallback; - dbg_create_info.pUserData = NULL; - LayerCreateMessengerCallback(debug_report, default_layer_callback, &dbg_create_info, &messenger); - } -} +#include "vulkan/vulkan_core.h" +#include "vk_layer_config.h" VkLayerInstanceCreateInfo *GetChainInfo(const VkInstanceCreateInfo *pCreateInfo, VkLayerFunction func) { VkLayerInstanceCreateInfo *chain_info = (VkLayerInstanceCreateInfo *)pCreateInfo->pNext; diff --git a/layers/utils/vk_layer_utils.h b/layers/utils/vk_layer_utils.h index e5b21c5b9a7..fc48a692407 100644 --- a/layers/utils/vk_layer_utils.h +++ b/layers/utils/vk_layer_utils.h @@ -28,6 +28,7 @@ #include #include +#include "vulkan/vk_layer.h" #include "generated/vk_extension_helper.h" #include "error_message/logging.h" @@ -447,8 +448,6 @@ typedef enum VkStringErrorFlagBits { } VkStringErrorFlagBits; typedef VkFlags VkStringErrorFlags; -void LayerDebugMessengerActions(DebugReport *debug_report, const char *layer_identifier); - std::string GetTempFilePath(); // Aliases to avoid excessive typing. We can't easily auto these away because diff --git a/layers/vk_layer_config.cpp b/layers/vk_layer_config.cpp index 6cfc5928d4c..c5d58ed5ce7 100644 --- a/layers/vk_layer_config.cpp +++ b/layers/vk_layer_config.cpp @@ -45,29 +45,6 @@ using std::string; -class ConfigFile { - public: - ConfigFile(); - ~ConfigFile(){}; - - const char *GetOption(const string &option); - void SetOption(const string &option, const string &value); - string vk_layer_disables_env_var; - SettingsFileInfo settings_info{}; - - private: - bool file_is_parsed_; - std::map value_map_; - - string FindSettings(); - void ParseFile(const char *filename); -}; - -ConfigFile &GetLayerConfig() { - static ConfigFile layer_config; - return layer_config; -} - #if defined(__ANDROID__) static void PropCallback(void *cookie, [[maybe_unused]] const char *name, const char *value, [[maybe_unused]] uint32_t serial) { std::string *property = static_cast(cookie); @@ -125,106 +102,6 @@ void SetEnvironment(const char *variable, const char *value) { #endif } -const char *getLayerOption(const char *option) { return GetLayerConfig().GetOption(option); } - -const SettingsFileInfo *GetLayerSettingsFileInfo() { return &GetLayerConfig().settings_info; } - -// If option is NULL or stdout, return stdout, otherwise try to open option -// as a filename. If successful, return file handle, otherwise stdout -FILE *getLayerLogOutput(const char *option, const char *layer_name) { - FILE *log_output = NULL; - if (!option || !strcmp("stdout", option)) { - log_output = stdout; - } else { - log_output = fopen(option, "w"); - if (log_output == NULL) { - if (option) { - std::cout << std::endl - << layer_name << " ERROR: Bad output filename specified: " << option << ". Writing to STDOUT instead" - << std::endl - << std::endl; - } - log_output = stdout; - } - } - return log_output; -} - -// Map option strings to flag enum values -VkFlags GetLayerOptionFlags(const string &option, vvl::unordered_map const &enum_data, uint32_t option_default) { - VkDebugReportFlagsEXT flags = option_default; - string option_list = GetLayerConfig().GetOption(option.c_str()); - - while (option_list.length() != 0) { - // Find length of option string - std::size_t option_length = option_list.find(','); - if (option_length == option_list.npos) { - option_length = option_list.size(); - } - - // Get first option item in list - const string option_item = option_list.substr(0, option_length); - - auto enum_value = enum_data.find(option_item); - if (enum_value != enum_data.end()) { - flags |= enum_value->second; - } - - // Remove first option from option_list - option_list.erase(0, option_length); - // Remove possible comma separator - std::size_t char_position = option_list.find(','); - if (char_position == 0) { - option_list.erase(char_position, 1); - } - // Remove possible space - char_position = option_list.find(' '); - if (char_position == 0) { - option_list.erase(char_position, 1); - } - } - return flags; -} - -// Constructor for ConfigFile. Initialize layers to log error messages to stdout by default. If a vk_layer_settings file is present, -// its settings will override the defaults. -ConfigFile::ConfigFile() : file_is_parsed_(false) { - value_map_["khronos_validation.report_flags"] = "error"; - -#ifdef WIN32 - // For Windows, enable message logging AND OutputDebugString - value_map_["khronos_validation.debug_action"] = - "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG,VK_DBG_LAYER_ACTION_DEBUG_OUTPUT"; -#else // WIN32 - value_map_["khronos_validation.debug_action"] = "VK_DBG_LAYER_ACTION_DEFAULT,VK_DBG_LAYER_ACTION_LOG_MSG"; -#endif // WIN32 - value_map_["khronos_validation.log_filename"] = "stdout"; - value_map_["khronos_validation.fine_grained_locking"] = "true"; -} - -const char *ConfigFile::GetOption(const string &option) { - std::map::const_iterator it; - if (!file_is_parsed_) { - string settings_file = FindSettings(); - ParseFile(settings_file.c_str()); - } - - if ((it = value_map_.find(option)) == value_map_.end()) { - return ""; - } else { - return it->second.c_str(); - } -} - -void ConfigFile::SetOption(const string &option, const string &val) { - if (!file_is_parsed_) { - string settings_file = FindSettings(); - ParseFile(settings_file.c_str()); - } - - value_map_[option] = val; -} - #if defined(WIN32) // Check for admin rights static inline bool IsHighIntegrity() { @@ -250,197 +127,6 @@ static inline bool IsHighIntegrity() { } #endif -string ConfigFile::FindSettings() { - struct stat info; - -#if defined(WIN32) - // Look for VkConfig-specific settings location specified in the windows registry - HKEY key; - - const std::array hives = {DEFAULT_VK_REGISTRY_HIVE, SECONDARY_VK_REGISTRY_HIVE}; - const size_t hives_to_check_count = IsHighIntegrity() ? 1 : hives.size(); // Admin checks only the default hive - - for (size_t hive_index = 0; hive_index < hives_to_check_count; ++hive_index) { - LSTATUS err = RegOpenKeyEx(hives[hive_index], "Software\\Khronos\\Vulkan\\Settings", 0, KEY_READ, &key); - if (err == ERROR_SUCCESS) { - char name[2048]; - DWORD i = 0, name_size, type, value, value_size; - while (ERROR_SUCCESS == RegEnumValue(key, i++, name, &(name_size = sizeof(name)), nullptr, &type, - reinterpret_cast(&value), &(value_size = sizeof(value)))) { - // Check if the registry entry is a dword with a value of zero - if (type != REG_DWORD || value != 0) { - continue; - } - - // Check if this actually points to a file - if ((stat(name, &info) != 0) || !(info.st_mode & S_IFREG)) { - continue; - } - - // Use this file - RegCloseKey(key); - settings_info.source = kVkConfig; - settings_info.location = name; - return name; - } - - RegCloseKey(key); - } - } - -#else - // Look for VkConfig-specific settings location specified in a specific spot in the linux settings store - string search_path = GetEnvironment("XDG_DATA_HOME"); - if (search_path == "") { - search_path = GetEnvironment("HOME"); - if (search_path != "") { - search_path += "/.local/share"; - } - } - // Use the vk_layer_settings.txt file from here, if it is present - if (search_path != "") { - string home_file = search_path + "/vulkan/settings.d/vk_layer_settings.txt"; - if (stat(home_file.c_str(), &info) == 0) { - if (info.st_mode & S_IFREG) { - settings_info.source = kVkConfig; - settings_info.location = home_file; - return home_file; - } - } - } - -#endif - // Look for an enviornment variable override for the settings file location - string env_path = GetEnvironment("VK_LAYER_SETTINGS_PATH"); - - // If the path exists use it, else use vk_layer_settings - if (stat(env_path.c_str(), &info) == 0) { - // If this is a directory, append settings file name - if (info.st_mode & S_IFDIR) { - env_path.append("/vk_layer_settings.txt"); - } - settings_info.source = kEnvVar; - settings_info.location = env_path; - return env_path; - } - - // Default -- use the current working directory for the settings file location - settings_info.source = kLocal; - char buff[512]; - auto buf_ptr = GetCurrentDir(buff, 512); - if (buf_ptr) { - settings_info.location = buf_ptr; - settings_info.location.append("\\vk_layer_settings.txt"); - } - return "vk_layer_settings.txt"; -} - -static inline std::string string_trim(const std::string &s) { - const char *whitespace = " \t\f\v\n\r"; - - const auto trimmed_beg = s.find_first_not_of(whitespace); - if (trimmed_beg == std::string::npos) return ""; - - const auto trimmed_end = s.find_last_not_of(whitespace); - assert(trimmed_end != std::string::npos && trimmed_beg <= trimmed_end); - - return s.substr(trimmed_beg, trimmed_end - trimmed_beg + 1); -} - -void ConfigFile::ParseFile(const char *filename) { - file_is_parsed_ = true; - - // Extract option = value pairs from a file - std::ifstream file(filename); - if (file.good()) { - settings_info.file_found = true; - for (string line; std::getline(file, line);) { - // discard comments, which start with '#' - const auto comments_pos = line.find_first_of('#'); - if (comments_pos != string::npos) line.erase(comments_pos); - - const auto value_pos = line.find_first_of('='); - if (value_pos != string::npos) { - const string option = string_trim(line.substr(0, value_pos)); - const string value = string_trim(line.substr(value_pos + 1)); - value_map_[option] = value; - } - } - } -} - -void PrintMessageFlags(VkFlags vk_flags, char *msg_flags) { - bool separator = false; - - msg_flags[0] = 0; - if (vk_flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) { - strcat(msg_flags, "DEBUG"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "INFO"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "WARN"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "PERF"); - separator = true; - } - if (vk_flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "ERROR"); - } -} - -void PrintMessageSeverity(VkFlags vk_flags, char *msg_flags) { - bool separator = false; - - msg_flags[0] = 0; - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) { - strcat(msg_flags, "VERBOSE"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "INFO"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "WARN"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "ERROR"); - } -} - -void PrintMessageType(VkFlags vk_flags, char *msg_flags) { - bool separator = false; - - msg_flags[0] = 0; - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) { - strcat(msg_flags, "GEN"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "SPEC"); - separator = true; - } - if (vk_flags & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) { - if (separator) strcat(msg_flags, ","); - strcat(msg_flags, "PERF"); - } -} - // Ensure we are properly setting VK_USE_PLATFORM_METAL_EXT, VK_USE_PLATFORM_IOS_MVK, and VK_USE_PLATFORM_MACOS_MVK. #if __APPLE__ diff --git a/layers/vk_layer_config.h b/layers/vk_layer_config.h index b454266446b..b3c6c0cc98a 100644 --- a/layers/vk_layer_config.h +++ b/layers/vk_layer_config.h @@ -16,64 +16,9 @@ **************************************************************************/ #pragma once -#include #include -#include "vulkan/vk_layer.h" -#include "vulkan/vulkan.h" -#include "containers/custom_containers.h" - -#if defined(WIN32) -#define DEFAULT_VK_REGISTRY_HIVE HKEY_LOCAL_MACHINE -#define DEFAULT_VK_REGISTRY_HIVE_STR "HKEY_LOCAL_MACHINE" -#define SECONDARY_VK_REGISTRY_HIVE HKEY_CURRENT_USER -#define SECONDARY_VK_REGISTRY_HIVE_STR "HKEY_CURRENT_USER" -#endif - std::string GetEnvironment(const char *variable); // Not supported on Android void SetEnvironment(const char *variable, const char *value); - -enum SettingsFileSource { - kVkConfig, - kEnvVar, - kLocal, -}; - -struct SettingsFileInfo { - bool file_found = false; - std::string location{}; - SettingsFileSource source = kLocal; -}; - -enum LogMessageTypeBits { - kInformationBit = 0x00000001, - kWarningBit = 0x00000002, - kPerformanceWarningBit = 0x00000004, - kErrorBit = 0x00000008, - kVerboseBit = 0x00000010, -}; -using LogMessageTypeFlags = VkFlags; - -// Definitions for Debug Actions -enum VkLayerDbgActionBits { - VK_DBG_LAYER_ACTION_IGNORE = 0x00000000, - VK_DBG_LAYER_ACTION_CALLBACK = 0x00000001, - VK_DBG_LAYER_ACTION_LOG_MSG = 0x00000002, - VK_DBG_LAYER_ACTION_BREAK = 0x00000004, - VK_DBG_LAYER_ACTION_DEBUG_OUTPUT = 0x00000008, - VK_DBG_LAYER_ACTION_DEFAULT = 0x40000000, -}; -using VkLayerDbgActionFlags = VkFlags; - -const char *getLayerOption(const char *option); -const SettingsFileInfo *GetLayerSettingsFileInfo(); - -FILE *getLayerLogOutput(const char *option, const char *layer_name); -VkFlags GetLayerOptionFlags(const std::string &option, vvl::unordered_map const &enum_data, - uint32_t option_default); - -void PrintMessageFlags(VkFlags vk_flags, char *msg_flags); -void PrintMessageSeverity(VkFlags vk_flags, char *msg_flags); -void PrintMessageType(VkFlags vk_flags, char *msg_flags); diff --git a/layers/vulkan/generated/chassis.cpp b/layers/vulkan/generated/chassis.cpp index c83b1e92dc0..1ed463d76a9 100644 --- a/layers/vulkan/generated/chassis.cpp +++ b/layers/vulkan/generated/chassis.cpp @@ -374,36 +374,12 @@ void OutputLayerStatusInfo(ValidationObject* context) { list_of_disables.append("None"); } - auto settings_info = GetLayerSettingsFileInfo(); - std::string settings_status; - if (!settings_info->file_found) { - settings_status = "None. Default location is "; - settings_status.append(settings_info->location); - settings_status.append("."); - } else { - settings_status = "Found at "; - settings_status.append(settings_info->location); - settings_status.append(" specified by "); - switch (settings_info->source) { - case kEnvVar: - settings_status.append("environment variable (VK_LAYER_SETTINGS_PATH)."); - break; - case kVkConfig: - settings_status.append("VkConfig application override."); - break; - case kLocal: // Intentionally fall through - default: - settings_status.append("default location (current working directory)."); - break; - } - } - Location loc(vvl::Func::vkCreateInstance); // Output layer status information message - context->LogInfo( - "WARNING-CreateInstance-status-message", context->instance, loc, - "Khronos Validation Layer Active:\n Settings File: %s\n Current Enables: %s.\n Current Disables: %s.\n", - settings_status.c_str(), list_of_enables.c_str(), list_of_disables.c_str()); + // TODO - We should just dump all settings to a file (see https://github.com/KhronosGroup/Vulkan-Utility-Libraries/issues/188) + context->LogInfo("WARNING-CreateInstance-status-message", context->instance, loc, + "Khronos Validation Layer Active:\n Current Enables: %s.\n Current Disables: %s.\n", + list_of_enables.c_str(), list_of_disables.c_str()); // Create warning message if user is running debug layers. #ifndef NDEBUG @@ -516,7 +492,6 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreat auto debug_report = new DebugReport{}; debug_report->instance_pnext_chain = vku::SafePnextCopy(pCreateInfo->pNext); ActivateInstanceDebugCallbacks(debug_report); - LayerDebugMessengerActions(debug_report, OBJECT_LAYER_DESCRIPTION); // Set up enable and disable features flags CHECK_ENABLED local_enables{}; diff --git a/layers/vulkan/generated/chassis.h b/layers/vulkan/generated/chassis.h index 573f14fe21f..de22379987e 100644 --- a/layers/vulkan/generated/chassis.h +++ b/layers/vulkan/generated/chassis.h @@ -42,7 +42,6 @@ #include #include #include "utils/cast_utils.h" -#include "vk_layer_config.h" #include "layer_options.h" #include "containers/custom_containers.h" #include "error_message/logging.h" diff --git a/scripts/generators/layer_chassis_generator.py b/scripts/generators/layer_chassis_generator.py index 7905923ab39..918d2687d06 100644 --- a/scripts/generators/layer_chassis_generator.py +++ b/scripts/generators/layer_chassis_generator.py @@ -311,7 +311,6 @@ def generateHeader(self): #include #include #include "utils/cast_utils.h" - #include "vk_layer_config.h" #include "layer_options.h" #include "containers/custom_containers.h" #include "error_message/logging.h" @@ -982,35 +981,12 @@ def generateSource(self): list_of_disables.append("None"); } - auto settings_info = GetLayerSettingsFileInfo(); - std::string settings_status; - if (!settings_info->file_found) { - settings_status = "None. Default location is "; - settings_status.append(settings_info->location); - settings_status.append("."); - } else { - settings_status = "Found at "; - settings_status.append(settings_info->location); - settings_status.append(" specified by "); - switch (settings_info->source) { - case kEnvVar: - settings_status.append("environment variable (VK_LAYER_SETTINGS_PATH)."); - break; - case kVkConfig: - settings_status.append("VkConfig application override."); - break; - case kLocal: // Intentionally fall through - default: - settings_status.append("default location (current working directory)."); - break; - } - } - Location loc(vvl::Func::vkCreateInstance); // Output layer status information message + // TODO - We should just dump all settings to a file (see https://github.com/KhronosGroup/Vulkan-Utility-Libraries/issues/188) context->LogInfo("WARNING-CreateInstance-status-message", context->instance, loc, - "Khronos Validation Layer Active:\\n Settings File: %s\\n Current Enables: %s.\\n Current Disables: %s.\\n", - settings_status.c_str(), list_of_enables.c_str(), list_of_disables.c_str()); + "Khronos Validation Layer Active:\\n Current Enables: %s.\\n Current Disables: %s.\\n", + list_of_enables.c_str(), list_of_disables.c_str()); // Create warning message if user is running debug layers. #ifndef NDEBUG @@ -1124,7 +1100,6 @@ def generateSource(self): auto debug_report = new DebugReport{}; debug_report->instance_pnext_chain = vku::SafePnextCopy(pCreateInfo->pNext); ActivateInstanceDebugCallbacks(debug_report); - LayerDebugMessengerActions(debug_report, OBJECT_LAYER_DESCRIPTION); // Set up enable and disable features flags CHECK_ENABLED local_enables{}; diff --git a/tests/framework/error_monitor.cpp b/tests/framework/error_monitor.cpp index d9ce8d9e522..5294690b9e5 100644 --- a/tests/framework/error_monitor.cpp +++ b/tests/framework/error_monitor.cpp @@ -17,6 +17,7 @@ */ #include "error_monitor.h" #include "test_common.h" +#include "error_message/log_message_type.h" #include "generated/vk_function_pointers.h" #ifdef VK_USE_PLATFORM_ANDROID_KHR diff --git a/tests/framework/error_monitor.h b/tests/framework/error_monitor.h index 913c6c50320..f0cc5f16333 100644 --- a/tests/framework/error_monitor.h +++ b/tests/framework/error_monitor.h @@ -22,8 +22,8 @@ #include #include -#include "vk_layer_config.h" -#include +#include "error_message/log_message_type.h" +#include // ErrorMonitor Usage: // diff --git a/tests/framework/render.cpp b/tests/framework/render.cpp index 70958433bc8..e629c66375e 100644 --- a/tests/framework/render.cpp +++ b/tests/framework/render.cpp @@ -26,6 +26,7 @@ #include "generated/vk_extension_helper.h" #include "layer_validation_tests.h" +#include "vk_layer_config.h" #if defined(VK_USE_PLATFORM_METAL_EXT) #include "apple_wsi.h"