| /* |
| * Copyright (c) 2016 Valve Corporation |
| * Copyright (c) 2016 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. |
| * |
| * Author: Mark Young <marky@lunarg.com> |
| */ |
| |
| #include <cstring> |
| #include <exception> |
| #include <fstream> |
| #include <iostream> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| #include <time.h> |
| #include <inttypes.h> |
| |
| const char APP_VERSION[] = "Version 1.0"; |
| #define MAX_STRING_LENGTH 1024 |
| |
| #ifdef _WIN32 |
| #pragma warning(disable : 4996) |
| #include "shlwapi.h" |
| #else |
| #include <stdlib.h> |
| #include <sys/types.h> |
| #include <sys/statvfs.h> |
| #include <sys/utsname.h> |
| #include <dirent.h> |
| #include <unistd.h> |
| #endif |
| |
| #include <json/json.h> |
| |
| #include <vulkan/vulkan.h> |
| |
| #if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/) || defined MINGW_HAS_SECURE_API |
| #include <basetsd.h> |
| #define snprintf sprintf_s |
| #endif |
| |
| enum ElementAlign { ALIGN_LEFT = 0, ALIGN_CENTER, ALIGN_RIGHT }; |
| |
| struct PhysicalDeviceInfo { |
| VkPhysicalDevice vulkan_phys_dev; |
| std::vector<VkQueueFamilyProperties> queue_fam_props; |
| }; |
| |
| struct GlobalItems { |
| std::ofstream html_file_stream; |
| bool sdk_found; |
| std::string sdk_path; |
| VkInstance instance; |
| std::vector<PhysicalDeviceInfo> phys_devices; |
| std::vector<VkDevice> log_devices; |
| uint32_t cur_table; |
| std::string exe_directory; |
| bool is_odd_row; |
| |
| #ifdef _WIN32 |
| bool is_wow64; |
| #endif |
| }; |
| |
| // Create a global variable used to store the global settings |
| GlobalItems global_items = {}; |
| |
| // Error messages thrown by the application |
| enum ErrorResults { |
| VULKAN_CANT_FIND_DRIVER = -2, |
| MISSING_DRIVER_REGISTRY = -3, |
| MISSING_DRIVER_JSON = -4, |
| MISSING_DRIVER_LIB = -5, |
| }; |
| |
| // Structure used to store name/value pairs read from the |
| // Vulkan layer settings file (if one exists). |
| struct SettingPair { |
| std::string name; |
| std::string value; |
| }; |
| |
| void StartOutput(std::string title); |
| void EndOutput(); |
| void PrintSystemInfo(void); |
| void PrintVulkanInfo(void); |
| void PrintDriverInfo(void); |
| void PrintRunTimeInfo(void); |
| void PrintSDKInfo(void); |
| void PrintExplicitLayerJsonInfo(const char *layer_json_filename, |
| Json::Value root, uint32_t num_cols); |
| void PrintImplicitLayerJsonInfo(const char *layer_json_filename, |
| Json::Value root); |
| void PrintLayerInfo(void); |
| void PrintLayerSettingsFileInfo(void); |
| void PrintTestResults(void); |
| std::string TrimWhitespace(const std::string &str, |
| const std::string &whitespace = " \t\n\r"); |
| |
| int main(int argc, char **argv) { |
| int err_val = 0; |
| try { |
| time_t time_raw_format; |
| struct tm *ptr_time; |
| char html_file_name[MAX_STRING_LENGTH]; |
| char full_file[MAX_STRING_LENGTH]; |
| char temp[MAX_STRING_LENGTH]; |
| const char* output_path = NULL; |
| bool generate_unique_file = false; |
| |
| // Check and handle command-line arguments |
| if (argc > 1) { |
| for (int iii = 1; iii < argc; iii++) { |
| if (0 == strcmp("--unique_output", argv[iii])) { |
| generate_unique_file = true; |
| } else if (0 == strcmp("--output_path", argv[iii]) && |
| argc > (iii + 1)) { |
| output_path = argv[iii + 1]; |
| ++iii; |
| } else { |
| std::cout << "Usage of via.exe:" << std::endl |
| << " via.exe [--unique_output] " |
| "[--output_path <path>]" << std::endl |
| << " [--unique_output] Optional " |
| "parameter to generate a unique html" |
| << std::endl << " " |
| "output file in the form " |
| "\'via_YYYY_MM_DD_HH_MM.html\'" |
| << std::endl << " [--output_path <path>" |
| "] Optional parameter to generate the output at" |
| << std::endl << " " |
| " a given path" << std::endl; |
| throw(-1); |
| } |
| } |
| } |
| |
| // If the user wants a specific output path, write it to the buffer |
| // and then continue writing the rest of the name below |
| size_t file_name_offset = 0; |
| if (output_path != NULL) { |
| file_name_offset = strlen(output_path) + 1; |
| strncpy(html_file_name, output_path, MAX_STRING_LENGTH - 1); |
| #ifdef _WIN32 |
| strncpy(html_file_name + file_name_offset - 1, "\\", |
| MAX_STRING_LENGTH - file_name_offset); |
| #else |
| strncpy(html_file_name + file_name_offset - 1, "/", |
| MAX_STRING_LENGTH - file_name_offset); |
| #endif |
| } |
| |
| // If the user wants a unique file, generate a file with the current |
| // time and date incorporated into it. |
| if (generate_unique_file) { |
| time(&time_raw_format); |
| ptr_time = localtime(&time_raw_format); |
| if (strftime(html_file_name + file_name_offset, |
| MAX_STRING_LENGTH - 1, |
| "via_%Y_%m_%d_%H_%M.html", ptr_time) == 0) { |
| std::cerr << "Couldn't prepare formatted string" << std::endl; |
| throw(-1); |
| } |
| } else { |
| strncpy(html_file_name + file_name_offset, "via.html", |
| MAX_STRING_LENGTH - 1 - file_name_offset); |
| } |
| |
| // Write the output file to the current executing directory, or, if |
| // that fails, write it out to the user's home folder. |
| global_items.html_file_stream.open(html_file_name); |
| if (global_items.html_file_stream.fail()) { |
| #ifdef _WIN32 |
| char home_drive[32]; |
| if (0 != GetEnvironmentVariableA("HOMEDRIVE", home_drive, 31) || |
| 0 != GetEnvironmentVariableA("HOMEPATH", temp, |
| MAX_STRING_LENGTH - 1)) { |
| std::cerr << "Error failed to get either HOMEDRIVE or HOMEPATH " |
| "from environment settings!" |
| << std::endl; |
| throw(-1); |
| } |
| snprintf(full_file, MAX_STRING_LENGTH - 1, "%s%s\\%s", home_drive, |
| temp, html_file_name); |
| #else |
| snprintf(full_file, MAX_STRING_LENGTH - 1, "~/%s", html_file_name); |
| #endif |
| global_items.html_file_stream.open(full_file); |
| if (global_items.html_file_stream.fail()) { |
| std::cerr << "Error failed opening html file stream to " |
| "either current" |
| " folder as " |
| << html_file_name << " or home folder as " |
| << full_file << std::endl; |
| throw(-1); |
| } |
| } |
| |
| global_items.cur_table = 0; |
| |
| // Determine where we are executing at. |
| #ifdef _WIN32 |
| int bytes = GetModuleFileName(NULL, temp, MAX_STRING_LENGTH - 1); |
| if (0 < bytes) { |
| std::string exe_location = temp; |
| global_items.exe_directory = |
| exe_location.substr(0, exe_location.rfind("\\")); |
| |
| size_t index = 0; |
| while (true) { |
| index = global_items.exe_directory.find("\\", index); |
| if (index == std::string::npos) { |
| break; |
| } |
| global_items.exe_directory.replace(index, 1, "/"); |
| index++; |
| } |
| } else { |
| global_items.exe_directory = ""; |
| } |
| |
| #elif __GNUC__ |
| ssize_t len = ::readlink("/proc/self/exe", temp, MAX_STRING_LENGTH - 1); |
| if (0 < len) { |
| std::string exe_location = temp; |
| global_items.exe_directory = |
| exe_location.substr(0, exe_location.rfind("/")); |
| } else { |
| global_items.exe_directory = ""; |
| } |
| #endif |
| |
| StartOutput("LunarG VIA"); |
| |
| PrintSystemInfo(); |
| PrintVulkanInfo(); |
| PrintTestResults(); |
| EndOutput(); |
| } catch (int e) { |
| // Print out a useful message for any common errors. |
| switch (e) { |
| case MISSING_DRIVER_REGISTRY: |
| std::cout << "ERROR: Failed to find Vulkan Driver JSON in registry" |
| << std::endl; |
| break; |
| case MISSING_DRIVER_JSON: |
| std::cout << "ERROR: Failed to find Vulkan Driver JSON" |
| << std::endl; |
| break; |
| case MISSING_DRIVER_LIB: |
| std::cout << "ERROR: Failed to find Vulkan Driver Lib" << std::endl; |
| break; |
| case VULKAN_CANT_FIND_DRIVER: |
| std::cout << "ERROR: Vulkan failed to find a compatible driver" |
| << std::endl; |
| break; |
| default: |
| std::cout << "ERROR: Uknown failure occurred. Refer to HTML for " |
| "more info" |
| << std::endl; |
| break; |
| } |
| err_val = e; |
| } |
| global_items.html_file_stream.close(); |
| |
| if (err_val == 0) { |
| std::cout << "SUCCESS: Validation completed properly" << std::endl; |
| } |
| return err_val; |
| } |
| |
| // Output helper functions: |
| //============================= |
| |
| // Start writing to the HTML file by creating the appropriate |
| // header information including the appropriate CSS and JavaScript |
| // items. |
| void StartOutput(std::string output) { |
| global_items.html_file_stream << "<!DOCTYPE html>" << std::endl; |
| global_items.html_file_stream << "<HTML lang=\"en\" xml:lang=\"en\" " |
| "xmlns=\"http://www.w3.org/1999/xhtml\">" |
| << std::endl; |
| global_items.html_file_stream << std::endl |
| << "<HEAD>" << std::endl |
| << " <TITLE>" << output << "</TITLE>" |
| << std::endl; |
| |
| global_items.html_file_stream |
| << " <META charset=\"UTF-8\">" << std::endl |
| << " <style media=\"screen\" type=\"text/css\">" << std::endl |
| << " html {" << std::endl |
| // By defining the color first, this won't override the background image |
| // (unless the images aren't there). |
| << " background-color: #0b1e48;" << std::endl |
| // The following changes try to load the text image twice (locally, then |
| // off the web) followed by the background image twice (locally, then |
| // off the web). The background color will only show if both background |
| // image loads fail. In this way, a user will see their local copy on |
| // their machine, while a person they share it with will see the web |
| // images (or the background color). |
| << " background-image: url(\"file:///" |
| << global_items.exe_directory << "/images/lunarg_via.png\"), " |
| << "url(\"https://vulkan.lunarg.com/img/lunarg_via.png\"), " |
| "url(\"file:///" |
| << global_items.exe_directory << "/images/bg-starfield.jpg\"), " |
| << "url(\"https://vulkan.lunarg.com/img/bg-starfield.jpg\");" |
| << std::endl |
| << " background-position: center top, center top, center, " |
| "center;" |
| << std::endl |
| << " -webkit-background-size: auto, auto, cover, cover;" |
| << std::endl |
| << " -moz-background-size: auto, auto, cover, cover;" |
| << std::endl |
| << " -o-background-size: auto, auto, cover, cover;" |
| << std::endl |
| << " background-size: auto, auto, cover, cover;" << std::endl |
| << " background-attachment: scroll, scroll, fixed, fixed;" |
| << std::endl |
| << " background-repeat: no-repeat, no-repeat, no-repeat, " |
| "no-repeat;" |
| << std::endl |
| << " }" << std::endl |
| // h1.section is used for section headers, and h1.version is used to |
| // print out the application version text (which shows up just under |
| // the title). |
| << " h1.section {" << std::endl |
| << " font-family: sans-serif;" << std::endl |
| << " font-size: 35px;" << std::endl |
| << " color: #FFFFFF;" << std::endl |
| << " }" << std::endl |
| << " h1.version {" << std::endl |
| << " font-family: sans-serif;" << std::endl |
| << " font-size: 25px;" << std::endl |
| << " color: #FFFFFF;" << std::endl |
| << " }" << std::endl |
| << " h2.note {" << std::endl |
| << " font-family: sans-serif;" << std::endl |
| << " font-size: 22px;" << std::endl |
| << " color: #FFFFFF;" << std::endl |
| << " }" << std::endl |
| << " table {" << std::endl |
| << " min-width: 600px;" << std::endl |
| << " width: 70%;" << std::endl |
| << " border-collapse: collapse;" << std::endl |
| << " border-color: grey;" << std::endl |
| << " font-family: sans-serif;" << std::endl |
| << " }" << std::endl |
| << " td.header {" << std::endl |
| << " padding: 18px;" << std::endl |
| << " border: 1px solid #ccc;" << std::endl |
| << " font-size: 18px;" << std::endl |
| << " color: #fff;" << std::endl |
| << " }" << std::endl |
| << " td.odd {" << std::endl |
| << " padding: 10px;" << std::endl |
| << " border: 1px solid #ccc;" << std::endl |
| << " font-size: 16px;" << std::endl |
| << " color: rgb(255, 255, 255);" << std::endl |
| << " }" << std::endl |
| << " td.even {" << std::endl |
| << " padding: 10px;" << std::endl |
| << " border: 1px solid #ccc;" << std::endl |
| << " font-size: 16px;" << std::endl |
| << " color: rgb(220, 220, 220);" << std::endl |
| << " }" << std::endl |
| << " tr.header {" << std::endl |
| << " background-color: rgba(255,255,255,0.5);" << std::endl |
| << " }" << std::endl |
| << " tr.odd {" << std::endl |
| << " background-color: rgba(0,0,0,0.6);" << std::endl |
| << " }" << std::endl |
| << " tr.even {" << std::endl |
| << " background-color: rgba(0,0,0,0.7);" << std::endl |
| << " }" << std::endl |
| << " </style>" << std::endl |
| << " <script src=\"https://ajax.googleapis.com/ajax/libs/jquery/" |
| << "2.2.4/jquery.min.js\"></script>" << std::endl |
| << " <script type=\"text/javascript\">" << std::endl |
| << " $( document ).ready(function() {" << std::endl |
| << " $('table tr:not(.header)').hide();" << std::endl |
| << " $('.header').click(function() {" << std::endl |
| << " " |
| "$(this).nextUntil('tr.header').slideToggle(300);" |
| << std::endl |
| << " });" << std::endl |
| << " });" << std::endl |
| << " </script>" << std::endl |
| << "</HEAD>" << std::endl |
| << std::endl |
| << "<BODY>" << std::endl |
| << std::endl; |
| // We need space from the top for the VIA texture |
| for (uint32_t space = 0; space < 15; space++) { |
| global_items.html_file_stream << " <BR />" << std::endl; |
| } |
| // All the silly " " are to make sure the version lines up directly |
| // under the VIA portion of the log. |
| global_items.html_file_stream << " <H1 class=\"version\"><center>"; |
| for (uint32_t space = 0; space < 65; space++) { |
| global_items.html_file_stream << " "; |
| } |
| global_items.html_file_stream << APP_VERSION << "</center></h1>" |
| << std::endl |
| << " <BR />" << std::endl; |
| |
| global_items.html_file_stream << APP_VERSION << "<center><h2 class=\"note\">< NOTE: Click on section name to expand table ></h2></center>" |
| << std::endl |
| << " <BR />" << std::endl; |
| } |
| |
| // Close out writing to the HTML file. |
| void EndOutput() { |
| global_items.html_file_stream << "</BODY>" << std::endl |
| << std::endl |
| << "</HTML>" << std::endl; |
| } |
| |
| void BeginSection(std::string section_str) { |
| global_items.html_file_stream << " <H1 class=\"section\"><center>" |
| << section_str << "</center></h1>" |
| << std::endl; |
| } |
| |
| void EndSection() { |
| global_items.html_file_stream << " <BR/>" << std::endl |
| << " <BR/>" << std::endl; |
| } |
| |
| void PrintStandardText(std::string section) { |
| global_items.html_file_stream << " <H2><font color=\"White\">" << section |
| << "</font></H2>" << std::endl; |
| } |
| |
| void PrintBeginTable(const char *table_name, uint32_t num_cols) { |
| |
| global_items.html_file_stream |
| << " <table align=\"center\">" << std::endl |
| << " <tr class=\"header\">" << std::endl |
| << " <td colspan=\"" << num_cols << "\" class=\"header\">" |
| << table_name << "</td>" << std::endl |
| << " </tr>" << std::endl; |
| |
| global_items.is_odd_row = true; |
| } |
| |
| void PrintBeginTableRow() { |
| std::string class_str = ""; |
| if (global_items.is_odd_row) { |
| class_str = " class=\"odd\""; |
| } else { |
| class_str = " class=\"even\""; |
| } |
| global_items.html_file_stream << " <tr" << class_str << ">" |
| << std::endl; |
| } |
| |
| void PrintTableElement(std::string element, ElementAlign align = ALIGN_LEFT) { |
| std::string align_str = ""; |
| std::string class_str = ""; |
| if (align == ALIGN_RIGHT) { |
| align_str = " align=\"right\""; |
| } |
| if (global_items.is_odd_row) { |
| class_str = " class=\"odd\""; |
| } else { |
| class_str = " class=\"even\""; |
| } |
| global_items.html_file_stream << " <td" << align_str << class_str |
| << ">" << element << "</td>" << std::endl; |
| } |
| |
| void PrintEndTableRow() { |
| global_items.html_file_stream << " </tr>" << std::endl; |
| global_items.is_odd_row = !global_items.is_odd_row; |
| } |
| |
| void PrintEndTable() { |
| global_items.html_file_stream << " </table>" << std::endl; |
| } |
| |
| // Generate the full library location for a file based on the location of |
| // the JSON file referencing it, and the library location contained in that |
| // JSON file. |
| bool GenerateLibraryPath(const char *json_location, const char *library_info, |
| const uint32_t max_length, char *library_location) { |
| bool success = false; |
| char final_path[MAX_STRING_LENGTH]; |
| char *working_string_ptr; |
| uint32_t len = |
| (max_length > MAX_STRING_LENGTH) ? MAX_STRING_LENGTH : max_length; |
| |
| if (NULL == json_location || NULL == library_info || |
| NULL == library_location) { |
| goto out; |
| } |
| |
| // Remove json file from json path to get just the file base location |
| strncpy(final_path, json_location, len); |
| working_string_ptr = strrchr(final_path, '\\'); |
| if (working_string_ptr == NULL) { |
| working_string_ptr = strrchr(final_path, '/'); |
| } |
| if (working_string_ptr != NULL) { |
| working_string_ptr++; |
| *working_string_ptr = '\0'; |
| } |
| |
| // Determine if the library is relative or absolute |
| if (library_info[0] == '\\' || library_info[0] == '/' || |
| library_info[1] == ':') { |
| // Absolute path |
| strncpy(library_location, library_info, len); |
| success = true; |
| } else { |
| uint32_t i = 0; |
| // Relative path, so we need to use the JSON's location |
| while (library_info[i] == '.' && library_info[i + 1] == '.' && |
| (library_info[i + 2] == '\\' || library_info[i + 2] == '/')) { |
| i += 3; |
| // Go up a folder in the json path |
| working_string_ptr = strrchr(final_path, '\\'); |
| if (working_string_ptr == NULL) { |
| working_string_ptr = strrchr(final_path, '/'); |
| } |
| if (working_string_ptr != NULL) { |
| working_string_ptr++; |
| *working_string_ptr = '\0'; |
| } |
| } |
| while (library_info[i] == '.' && |
| (library_info[i + 1] == '\\' || library_info[i + 1] == '/')) { |
| i += 2; |
| } |
| strncpy(library_location, final_path, MAX_STRING_LENGTH - 1); |
| strncat(library_location, &library_info[i], len); |
| success = true; |
| } |
| |
| out: |
| return success; |
| } |
| |
| #ifdef _WIN32 |
| // Registry utility fuctions to simplify reading data from the |
| // Windows registry. |
| |
| const char g_uninstall_reg_path[] = |
| "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall"; |
| |
| bool ReadRegKeyString(HKEY regFolder, const char *keyPath, |
| const char *valueName, const int maxLength, |
| char *retString) { |
| bool retVal = false; |
| DWORD bufLen = maxLength; |
| DWORD keyFlags = KEY_READ; |
| HKEY hKey; |
| LONG lret; |
| |
| if (global_items.is_wow64) { |
| keyFlags |= KEY_WOW64_64KEY; |
| } |
| |
| *retString = '\0'; |
| lret = RegOpenKeyExA(regFolder, keyPath, 0, keyFlags, &hKey); |
| if (lret == ERROR_SUCCESS) { |
| lret = RegQueryValueExA(hKey, valueName, NULL, NULL, (BYTE *)retString, |
| &bufLen); |
| if (lret == ERROR_SUCCESS) { |
| retVal = true; |
| } |
| RegCloseKey(hKey); |
| } |
| |
| return retVal; |
| } |
| |
| bool WriteRegKeyString(HKEY regFolder, const char *keyPath, char *valueName, |
| char *valueValue) { |
| bool retVal = false; |
| DWORD keyFlags = KEY_WRITE; |
| HKEY hKey; |
| LONG lret; |
| |
| if (global_items.is_wow64) { |
| keyFlags |= KEY_WOW64_64KEY; |
| } |
| |
| lret = RegOpenKeyExA(regFolder, keyPath, 0, keyFlags, &hKey); |
| if (lret == ERROR_SUCCESS) { |
| lret = RegSetKeyValueA(hKey, NULL, valueName, REG_SZ, |
| (BYTE *)valueValue, (DWORD)(strlen(valueValue))); |
| if (lret == ERROR_SUCCESS) { |
| retVal = true; |
| } |
| RegCloseKey(hKey); |
| } |
| |
| return retVal; |
| } |
| |
| bool DeleteRegKeyString(HKEY regFolder, const char *keyPath, char *valueName) { |
| bool retVal = false; |
| DWORD keyFlags = KEY_WRITE; |
| HKEY hKey; |
| LONG lret; |
| |
| if (global_items.is_wow64) { |
| keyFlags |= KEY_WOW64_64KEY; |
| } |
| |
| lret = RegOpenKeyExA(regFolder, keyPath, 0, keyFlags, &hKey); |
| if (lret == ERROR_SUCCESS) { |
| lret = RegDeleteKeyValueA(hKey, NULL, valueName); |
| if (lret == ERROR_SUCCESS) { |
| retVal = true; |
| } |
| RegCloseKey(hKey); |
| } |
| |
| return retVal; |
| } |
| |
| bool ReadRegKeyDword(HKEY regFolder, const char *keyPath, const char *valueName, |
| unsigned int *returnInt) { |
| bool retVal = false; |
| DWORD bufLen = sizeof(DWORD); |
| DWORD keyFlags = KEY_READ; |
| HKEY hKey; |
| LONG lret; |
| |
| if (global_items.is_wow64) { |
| keyFlags |= KEY_WOW64_64KEY; |
| } |
| |
| *returnInt = 0; |
| lret = RegOpenKeyExA(regFolder, keyPath, 0, keyFlags, &hKey); |
| if (lret == ERROR_SUCCESS) { |
| lret = RegQueryValueExA(hKey, valueName, NULL, NULL, (BYTE *)returnInt, |
| &bufLen); |
| if (lret == ERROR_SUCCESS) { |
| retVal = true; |
| } |
| RegCloseKey(hKey); |
| } |
| |
| return retVal; |
| } |
| |
| bool FindNextRegKey(HKEY regFolder, const char *keyPath, const char *keySearch, |
| const int itemIndex, const int maxLength, char *retString) { |
| bool retVal = false; |
| DWORD bufLen = MAX_STRING_LENGTH - 1; |
| DWORD keyFlags = KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE; |
| HKEY hKey; |
| LONG lret; |
| int itemCount = 0; |
| |
| if (global_items.is_wow64) { |
| keyFlags |= KEY_WOW64_64KEY; |
| } |
| |
| *retString = '\0'; |
| lret = RegOpenKeyExA(regFolder, keyPath, 0, keyFlags, &hKey); |
| if (lret == ERROR_SUCCESS) { |
| DWORD index = 0; |
| char keyName[MAX_STRING_LENGTH]; |
| |
| do { |
| lret = RegEnumKeyExA(hKey, index, keyName, &bufLen, NULL, NULL, |
| NULL, NULL); |
| if (ERROR_SUCCESS != lret) { |
| break; |
| } |
| if (strlen(keySearch) == 0 || NULL != strstr(keyName, keySearch)) { |
| if (itemIndex == itemCount) { |
| strncpy_s(retString, maxLength, keyName, bufLen); |
| retVal = true; |
| break; |
| } else { |
| itemCount++; |
| } |
| } |
| bufLen = MAX_STRING_LENGTH - 1; |
| ++index; |
| } while (true); |
| } |
| |
| return retVal; |
| } |
| |
| bool FindNextRegValue(HKEY regFolder, const char *keyPath, |
| const char *valueSearch, const int startIndex, |
| const int maxLength, char *retString, uint32_t *retValue) { |
| bool retVal = false; |
| DWORD bufLen = MAX_STRING_LENGTH - 1; |
| DWORD keyFlags = KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE; |
| HKEY hKey = 0; |
| LONG lret; |
| |
| if (global_items.is_wow64) { |
| keyFlags |= KEY_WOW64_64KEY; |
| } |
| |
| *retValue = 0; |
| *retString = '\0'; |
| lret = RegOpenKeyExA(regFolder, keyPath, 0, keyFlags, &hKey); |
| if (lret == ERROR_SUCCESS) { |
| DWORD index = startIndex; |
| char valueName[MAX_STRING_LENGTH]; |
| |
| do { |
| DWORD type = REG_DWORD; |
| DWORD value = 0; |
| DWORD len = 4; |
| valueName[0] = '\0'; |
| |
| lret = RegEnumValueA(hKey, index, valueName, &bufLen, NULL, &type, |
| (LPBYTE)&value, &len); |
| if (ERROR_SUCCESS != lret) { |
| break; |
| } |
| if (type == REG_DWORD) { |
| *retValue = value; |
| } |
| if (strlen(valueSearch) == 0 || |
| NULL != strstr(valueName, valueSearch)) { |
| strncpy_s(retString, maxLength, valueName, bufLen); |
| retVal = true; |
| break; |
| } |
| |
| bufLen = MAX_STRING_LENGTH - 1; |
| ++index; |
| } while (true); |
| } |
| |
| return retVal; |
| } |
| |
| // Registry prototypes for Windows |
| bool ReadRegKeyDword(HKEY regFolder, const char *keyPath, const char *valueName, |
| unsigned int *returnInt); |
| bool ReadRegKeyString(HKEY regFolder, const char *keyPath, |
| const char *valueName, const int maxLength, |
| char *retString); |
| bool FindNextRegKey(HKEY regFolder, const char *keyPath, const char *keySearch, |
| const int startIndex, const int maxLength, char *retString); |
| bool FindNextRegValue(HKEY regFolder, const char *keyPath, |
| const char *valueSearch, const int startIndex, |
| const int maxLength, char *retString, uint32_t *retValue); |
| bool WriteRegKeyString(HKEY regFolder, const char *keyPath, char *valueName, |
| char *valueValue); |
| bool DeleteRegKeyString(HKEY regFolder, const char *keyPath, char *valueName); |
| |
| // Functionality to determine if this 32-bit process is running on Windows 64. |
| // |
| void IsWow64() { |
| typedef BOOL(WINAPI * LPFN_ISWOW64PROCESS)(HANDLE, PBOOL); |
| |
| // IsWow64Process is not available on all supported versions of Windows. |
| // Use GetModuleHandle to get a handle to the DLL that contains the function |
| // and GetProcAddress to get a pointer to the function if available. |
| |
| LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress( |
| GetModuleHandle(TEXT("kernel32")), "IsWow64Process"); |
| |
| if (NULL != fnIsWow64Process) { |
| BOOL isWOW = FALSE; |
| if (!fnIsWow64Process(GetCurrentProcess(), &isWOW)) { |
| printf("Error : Failed to determine properly if on Win64!"); |
| } |
| |
| if (isWOW == TRUE) { |
| global_items.is_wow64 = true; |
| } |
| } |
| } |
| |
| // Run the test in the specified directory with the corresponding |
| // command-line arguments. |
| // Returns 0 on no error, 1 if test file wasn't found, and -1 |
| // on any other errors. |
| int RunTestInDirectory(std::string path, std::string test, |
| std::string cmd_line) { |
| int err_code = -1; |
| char orig_dir[MAX_STRING_LENGTH]; |
| orig_dir[0] = '\0'; |
| if (0 != GetCurrentDirectoryA(MAX_STRING_LENGTH - 1, orig_dir) && |
| TRUE == SetCurrentDirectoryA(path.c_str())) { |
| if (TRUE == PathFileExists(test.c_str())) { |
| err_code = system(cmd_line.c_str()); |
| } else { |
| // Path to specific exe doesn't exist |
| err_code = 1; |
| } |
| SetCurrentDirectoryA(orig_dir); |
| } else { |
| // Path to test doesn't exist. |
| err_code = 1; |
| } |
| return err_code; |
| } |
| |
| // Print out any information about the current system that we can |
| // capture to ease in debugging/investigation at a later time. |
| void PrintSystemInfo(void) { |
| OSVERSIONINFOEX os_info; |
| SYSTEM_INFO sys_info; |
| MEMORYSTATUSEX mem_stat; |
| DWORD ser_ver = 0; |
| DWORD sect_per_cluster = 0; |
| DWORD bytes_per_sect = 0; |
| DWORD num_free_cluster = 0; |
| DWORD total_num_cluster = 0; |
| char system_root_dir[MAX_STRING_LENGTH]; |
| char generic_string[MAX_STRING_LENGTH]; |
| char output_string[MAX_STRING_LENGTH]; |
| char os_size[32]; |
| std::string cur_directory; |
| std::string exe_directory; |
| |
| // Determine if this 32-bit process is on Win64. |
| IsWow64(); |
| |
| #if _WIN64 |
| strncpy(os_size, " 64-bit", 31); |
| #else |
| strncpy(os_size, " 32-bit", 31); |
| #endif |
| |
| BeginSection("System Info"); |
| |
| // Environment section has information about the OS and the |
| // execution environment. |
| PrintBeginTable("Environment", 3); |
| |
| ZeroMemory(&sys_info, sizeof(SYSTEM_INFO)); |
| GetSystemInfo(&sys_info); |
| |
| ZeroMemory(&os_info, sizeof(OSVERSIONINFOEX)); |
| os_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); |
| |
| ZeroMemory(&mem_stat, sizeof(MEMORYSTATUSEX)); |
| mem_stat.dwLength = sizeof(MEMORYSTATUSEX); |
| |
| // Since this is Windows #ifdef code, determine the version of Windows |
| // that the applciation is running on. It's not trivial and has to |
| // refer to items queried in the above structures as well as the |
| // Windows registry. |
| if (TRUE == GetVersionEx((LPOSVERSIONINFO)(&os_info))) { |
| switch (os_info.dwMajorVersion) { |
| case 10: |
| if (os_info.wProductType == VER_NT_WORKSTATION) { |
| if (ReadRegKeyString( |
| HKEY_LOCAL_MACHINE, |
| "Software\\Microsoft\\Windows NT\\CurrentVersion", |
| "ProductName", MAX_STRING_LENGTH - 1, generic_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement(generic_string); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| |
| if (ReadRegKeyString( |
| HKEY_LOCAL_MACHINE, |
| "Software\\Microsoft\\Windows NT\\CurrentVersion", |
| "CurrentBuild", MAX_STRING_LENGTH - 1, |
| output_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Build"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| if (ReadRegKeyString( |
| HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windo" |
| "ws NT\\CurrentVersion", |
| "BuildBranch", MAX_STRING_LENGTH - 1, |
| output_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Branch"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows 10 (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows Server 2016 (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } |
| break; |
| case 6: |
| switch (os_info.dwMinorVersion) { |
| case 3: |
| if (os_info.wProductType == VER_NT_WORKSTATION) { |
| if (ReadRegKeyString( |
| HKEY_LOCAL_MACHINE, |
| "Software\\Microsoft\\Windows NT\\CurrentVersion", |
| "ProductName", MAX_STRING_LENGTH - 1, |
| generic_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement(generic_string); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| |
| if (ReadRegKeyString( |
| HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windo" |
| "ws NT\\CurrentVersion", |
| "CurrentBuild", MAX_STRING_LENGTH - 1, |
| output_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Build"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| |
| if (ReadRegKeyString(HKEY_LOCAL_MACHINE, |
| "Software\\Microsoft\\Windo" |
| "ws NT\\CurrentVersion", |
| "BuildBranch", |
| MAX_STRING_LENGTH - 1, |
| output_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Branch"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows Server 2012 R2 (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } |
| break; |
| case 2: |
| if (os_info.wProductType == VER_NT_WORKSTATION) { |
| if (ReadRegKeyString( |
| HKEY_LOCAL_MACHINE, |
| "Software\\Microsoft\\Windows NT\\CurrentVersion", |
| "ProductName", MAX_STRING_LENGTH - 1, |
| generic_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement(generic_string); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| |
| if (ReadRegKeyString( |
| HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windo" |
| "ws NT\\CurrentVersion", |
| "CurrentBuild", MAX_STRING_LENGTH - 1, |
| output_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Build"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| if (ReadRegKeyString(HKEY_LOCAL_MACHINE, |
| "Software\\Microsoft\\Windo" |
| "ws NT\\CurrentVersion", |
| "BuildBranch", |
| MAX_STRING_LENGTH - 1, |
| output_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Branch"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows Server 2012 (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } |
| break; |
| case 1: |
| if (os_info.wProductType == VER_NT_WORKSTATION) { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows 7 (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows Server 2008 R2 (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } |
| break; |
| default: |
| if (os_info.wProductType == VER_NT_WORKSTATION) { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows Vista (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows Server 2008 (or newer)"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| } |
| break; |
| } |
| break; |
| case 5: |
| ser_ver = GetSystemMetrics(SM_SERVERR2); |
| switch (os_info.dwMinorVersion) { |
| case 2: |
| if ((os_info.wProductType == VER_NT_WORKSTATION) && |
| (sys_info.wProcessorArchitecture == |
| PROCESSOR_ARCHITECTURE_AMD64)) { |
| strncpy(generic_string, "Windows XP Professional x64", |
| MAX_STRING_LENGTH - 1); |
| } else if (os_info.wSuiteMask & VER_SUITE_WH_SERVER) { |
| strncpy(generic_string, "Windows Home Server", |
| MAX_STRING_LENGTH - 1); |
| } else if (ser_ver != 0) { |
| strncpy(generic_string, "Windows Server 2003 R2", |
| MAX_STRING_LENGTH - 1); |
| } else { |
| strncpy(generic_string, "Windows Server 2003", |
| MAX_STRING_LENGTH - 1); |
| } |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement(generic_string); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| break; |
| case 1: |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows XP"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| break; |
| case 0: |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Windows 2000"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| break; |
| default: |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Unknown Windows OS"); |
| PrintTableElement(os_size); |
| PrintEndTableRow(); |
| break; |
| } |
| break; |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("Windows"); |
| PrintTableElement("Error retrieving Windows Version"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| throw(-1); |
| } |
| |
| if (0 != GetEnvironmentVariableA("SYSTEMROOT", system_root_dir, |
| MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("System Root"); |
| PrintTableElement(system_root_dir); |
| PrintEndTableRow(); |
| } |
| if (0 != GetEnvironmentVariableA("PROGRAMDATA", generic_string, |
| MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Program Data"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| if (0 != GetEnvironmentVariableA("PROGRAMFILES", generic_string, |
| MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Program Files"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| if (0 != GetEnvironmentVariableA("PROGRAMFILES(X86)", generic_string, |
| MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Program Files (x86)"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| if (0 != GetEnvironmentVariableA("TEMP", generic_string, |
| MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("TEMP"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| if (0 != |
| GetEnvironmentVariableA("TMP", generic_string, MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("TMP"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| |
| PrintEndTable(); |
| |
| // Output whatever generic hardware information we can find out about the |
| // system. Including how much memory and disk space is available. |
| PrintBeginTable("Hardware", 3); |
| |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u", |
| sys_info.dwNumberOfProcessors); |
| PrintBeginTableRow(); |
| PrintTableElement("CPUs"); |
| PrintTableElement("Number of Logical Cores"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| switch (sys_info.wProcessorArchitecture) { |
| case PROCESSOR_ARCHITECTURE_AMD64: |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Type"); |
| PrintTableElement("x86_64"); |
| PrintEndTableRow(); |
| break; |
| case PROCESSOR_ARCHITECTURE_ARM: |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Type"); |
| PrintTableElement("ARM"); |
| PrintEndTableRow(); |
| break; |
| case PROCESSOR_ARCHITECTURE_IA64: |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Type"); |
| PrintTableElement("IA64"); |
| PrintEndTableRow(); |
| break; |
| case PROCESSOR_ARCHITECTURE_INTEL: |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Type"); |
| PrintTableElement("x86"); |
| PrintEndTableRow(); |
| break; |
| default: |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Type"); |
| PrintTableElement("Unknown"); |
| PrintEndTableRow(); |
| break; |
| } |
| |
| if (TRUE == GlobalMemoryStatusEx(&mem_stat)) { |
| if ((mem_stat.ullTotalPhys >> 40) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u TB", |
| static_cast<uint32_t>(mem_stat.ullTotalPhys >> 40)); |
| PrintBeginTableRow(); |
| PrintTableElement("Memory"); |
| PrintTableElement("Physical"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((mem_stat.ullTotalPhys >> 30) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u GB", |
| static_cast<uint32_t>(mem_stat.ullTotalPhys >> 30)); |
| PrintBeginTableRow(); |
| PrintTableElement("Memory"); |
| PrintTableElement("Physical"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((mem_stat.ullTotalPhys >> 20) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u MB", |
| static_cast<uint32_t>(mem_stat.ullTotalPhys >> 20)); |
| PrintBeginTableRow(); |
| PrintTableElement("Memory"); |
| PrintTableElement("Physical"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((mem_stat.ullTotalPhys >> 10) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u KB", |
| static_cast<uint32_t>(mem_stat.ullTotalPhys >> 10)); |
| PrintBeginTableRow(); |
| PrintTableElement("Memory"); |
| PrintTableElement("Physical"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u bytes", |
| static_cast<uint32_t>(mem_stat.ullTotalPhys)); |
| PrintBeginTableRow(); |
| PrintTableElement("Memory"); |
| PrintTableElement("Physical"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } |
| |
| if (TRUE == GetDiskFreeSpaceA(NULL, §_per_cluster, &bytes_per_sect, |
| &num_free_cluster, &total_num_cluster)) { |
| uint64_t bytes_free = (uint64_t)bytes_per_sect * |
| (uint64_t)sect_per_cluster * |
| (uint64_t)num_free_cluster; |
| uint64_t bytes_total = (uint64_t)bytes_per_sect * |
| (uint64_t)sect_per_cluster * |
| (uint64_t)total_num_cluster; |
| double perc_free = (double)bytes_free / (double)bytes_total; |
| if ((bytes_total >> 40) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u TB", |
| static_cast<uint32_t>(bytes_total >> 40)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Total"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((bytes_total >> 30) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u GB", |
| static_cast<uint32_t>(bytes_total >> 30)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Total"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((bytes_total >> 20) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u MB", |
| static_cast<uint32_t>(bytes_total >> 20)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Total"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((bytes_total >> 10) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u KB", |
| static_cast<uint32_t>(bytes_total >> 10)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Total"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| snprintf(output_string, MAX_STRING_LENGTH - 1, "%4.2f%%", |
| (static_cast<float>(perc_free) * 100.f)); |
| if ((bytes_free >> 40) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u TB", |
| static_cast<uint32_t>(bytes_free >> 40)); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free Perc"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } else if ((bytes_free >> 30) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u GB", |
| static_cast<uint32_t>(bytes_free >> 30)); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free Perc"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } else if ((bytes_free >> 20) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u MB", |
| static_cast<uint32_t>(bytes_free >> 20)); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free Perc"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } else if ((bytes_free >> 10) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u KB", |
| static_cast<uint32_t>(bytes_free >> 10)); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Free Perc"); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } |
| } |
| |
| PrintEndTable(); |
| |
| // Print out information about this executable. |
| PrintBeginTable("Executable", 2); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Exe Directory"); |
| PrintTableElement(global_items.exe_directory); |
| PrintEndTableRow(); |
| |
| if (0 != GetCurrentDirectoryA(MAX_STRING_LENGTH - 1, generic_string)) { |
| cur_directory = generic_string; |
| PrintBeginTableRow(); |
| PrintTableElement("Current Directory"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else { |
| cur_directory = ""; |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Vulkan API Version"); |
| uint32_t major = VK_VERSION_MAJOR(VK_API_VERSION_1_0); |
| uint32_t minor = VK_VERSION_MINOR(VK_API_VERSION_1_0); |
| uint32_t patch = VK_VERSION_PATCH(VK_HEADER_VERSION); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d.%d.%d", major, minor, |
| patch); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Byte Format"); |
| #if _WIN64 || __x86_64__ || __ppc64__ |
| PrintTableElement("64-bit"); |
| #else |
| PrintTableElement("32-bit"); |
| #endif |
| PrintEndTableRow(); |
| |
| PrintEndTable(); |
| |
| // Now print out the remaining system info. |
| PrintDriverInfo(); |
| PrintRunTimeInfo(); |
| PrintSDKInfo(); |
| PrintLayerInfo(); |
| PrintLayerSettingsFileInfo(); |
| EndSection(); |
| } |
| |
| // Determine what version an executable or library file is. |
| bool GetFileVersion(const char *filename, const uint32_t max_len, |
| char *version_string) { |
| DWORD ver_handle; |
| UINT size = 0; |
| LPBYTE buffer = NULL; |
| DWORD ver_size = GetFileVersionInfoSize(filename, &ver_handle); |
| bool success = false; |
| |
| if (ver_size > 0) { |
| LPSTR ver_data = (LPSTR)malloc(sizeof(char) * ver_size); |
| |
| if (GetFileVersionInfo(filename, ver_handle, ver_size, ver_data)) { |
| if (VerQueryValue(ver_data, "\\", (VOID FAR * FAR *)&buffer, |
| &size)) { |
| if (size) { |
| VS_FIXEDFILEINFO *ver_info = (VS_FIXEDFILEINFO *)buffer; |
| if (ver_info->dwSignature == 0xfeef04bd) { |
| DWORD max_size = |
| ver_size > max_len ? max_len : ver_size; |
| snprintf(version_string, max_len, "%d.%d.%d.%d", |
| (ver_info->dwFileVersionMS >> 16) & 0xffff, |
| (ver_info->dwFileVersionMS >> 0) & 0xffff, |
| (ver_info->dwFileVersionLS >> 16) & 0xffff, |
| (ver_info->dwFileVersionLS >> 0) & 0xffff); |
| success = true; |
| } |
| } |
| } |
| } |
| free(ver_data); |
| } |
| |
| return success; |
| } |
| |
| // Print out the information for every driver in the appropriate |
| // Windows registry location and its corresponding JSON file. |
| void PrintDriverInfo(void) { |
| bool failed = false; |
| const char vulkan_reg_base[] = "SOFTWARE\\Khronos\\Vulkan"; |
| const char vulkan_reg_base_wow64[] = |
| "SOFTWARE\\WOW6432Node\\Khronos\\Vulkan"; |
| char reg_key_loc[MAX_STRING_LENGTH]; |
| char cur_vulkan_driver_json[MAX_STRING_LENGTH]; |
| char generic_string[MAX_STRING_LENGTH]; |
| char full_driver_path[MAX_STRING_LENGTH]; |
| char system_path[MAX_STRING_LENGTH]; |
| char count_str[64]; |
| uint32_t i = 0; |
| uint32_t j = 0; |
| std::ifstream *stream = NULL; |
| bool found_registry = false; |
| bool found_json = false; |
| bool found_lib = false; |
| |
| GetEnvironmentVariableA("SYSTEMROOT", generic_string, MAX_STRING_LENGTH); |
| #if _WIN64 || __x86_64__ || __ppc64__ |
| snprintf(system_path, MAX_STRING_LENGTH - 1, "%s\\system32\\", |
| generic_string); |
| snprintf(reg_key_loc, MAX_STRING_LENGTH - 1, "%s\\Drivers", |
| vulkan_reg_base); |
| #else |
| if (global_items.is_wow64) { |
| snprintf(system_path, MAX_STRING_LENGTH - 1, "%s\\sysWOW64\\", |
| generic_string); |
| snprintf(reg_key_loc, MAX_STRING_LENGTH - 1, "%s\\Drivers", |
| vulkan_reg_base_wow64); |
| } else { |
| snprintf(system_path, MAX_STRING_LENGTH - 1, "%s\\system32\\", |
| generic_string); |
| snprintf(reg_key_loc, MAX_STRING_LENGTH - 1, "%s\\Drivers", |
| vulkan_reg_base); |
| } |
| #endif |
| |
| PrintBeginTable("Vulkan Driver Info", 3); |
| PrintBeginTableRow(); |
| PrintTableElement("Registry Location"); |
| PrintTableElement(reg_key_loc); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // Find the registry settings indicating the location of the driver |
| // JSON files. |
| uint32_t returned_value = 0; |
| while (FindNextRegValue(HKEY_LOCAL_MACHINE, reg_key_loc, "", i, |
| MAX_STRING_LENGTH - 1, cur_vulkan_driver_json, |
| &returned_value)) { |
| found_registry = true; |
| |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "Driver %d", i++); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(cur_vulkan_driver_json); |
| |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%08x", |
| returned_value); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| // Parse the driver JSON file. |
| std::ifstream *stream = NULL; |
| stream = new std::ifstream(cur_vulkan_driver_json, std::ifstream::in); |
| if (nullptr == stream || stream->fail()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Error reading JSON file"); |
| PrintTableElement(cur_vulkan_driver_json); |
| PrintEndTableRow(); |
| |
| failed = true; |
| continue; |
| } else { |
| Json::Value root = Json::nullValue; |
| Json::Reader reader; |
| if (!reader.parse(*stream, root, false) || root.isNull()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Error reading JSON file"); |
| PrintTableElement(reader.getFormattedErrorMessages()); |
| PrintEndTableRow(); |
| |
| failed = true; |
| stream->close(); |
| delete stream; |
| continue; |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("JSON File Version"); |
| if (!root["file_format_version"].isNull()) { |
| PrintTableElement(root["file_format_version"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| PrintEndTableRow(); |
| |
| if (!root["ICD"].isNull()) { |
| found_json = true; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("API Version"); |
| if (!root["ICD"]["api_version"].isNull()) { |
| PrintTableElement( |
| root["ICD"]["api_version"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Library Path"); |
| if (!root["ICD"]["library_path"].isNull()) { |
| std::string driver_name = root["ICD"]["library_path"].asString(); |
| std::string system_name = system_path; |
| system_name += "\\"; |
| system_name += driver_name; |
| PrintTableElement(driver_name); |
| PrintEndTableRow(); |
| |
| if (GenerateLibraryPath( |
| cur_vulkan_driver_json, |
| driver_name.c_str(), |
| MAX_STRING_LENGTH - 1, full_driver_path)) { |
| |
| if (GetFileVersion(full_driver_path, |
| MAX_STRING_LENGTH - 1, |
| generic_string)) { |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Library File Version"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| found_lib = true; |
| } else if (GetFileVersion(system_name.c_str(), |
| MAX_STRING_LENGTH - 1, |
| generic_string)) { |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Library File Version"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| found_lib = true; |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "Failed to find driver %s " |
| " or %sreferenced by JSON %s", |
| root["ICD"]["library_path"] |
| .asString() |
| .c_str(), |
| full_driver_path, |
| cur_vulkan_driver_json); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "Failed to find driver %s " |
| "referenced by JSON %s", |
| full_driver_path, cur_vulkan_driver_json); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } else { |
| PrintTableElement("MISSING!"); |
| PrintEndTableRow(); |
| } |
| |
| j = 0; |
| Json::Value dev_exts = root["ICD"]["device_extensions"]; |
| if (!dev_exts.isNull() && dev_exts.isArray()) { |
| snprintf(count_str, MAX_STRING_LENGTH - 1, "%d", |
| dev_exts.size()); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Device Extensions"); |
| PrintTableElement(count_str); |
| PrintEndTableRow(); |
| |
| for (Json::ValueIterator dev_ext_it = dev_exts.begin(); |
| dev_ext_it != dev_exts.end(); dev_ext_it++) { |
| Json::Value dev_ext = (*dev_ext_it); |
| Json::Value dev_ext_name = dev_ext["name"]; |
| if (!dev_ext_name.isNull()) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "[%d]", j); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(dev_ext_name.asString()); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| Json::Value inst_exts = root["ICD"]["instance_extensions"]; |
| j = 0; |
| if (!inst_exts.isNull() && inst_exts.isArray()) { |
| snprintf(count_str, MAX_STRING_LENGTH - 1, "%d", |
| inst_exts.size()); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Instance Extensions"); |
| PrintTableElement(count_str); |
| PrintEndTableRow(); |
| |
| for (Json::ValueIterator inst_ext_it = |
| inst_exts.begin(); |
| inst_ext_it != inst_exts.end(); inst_ext_it++) { |
| Json::Value inst_ext = (*inst_ext_it); |
| Json::Value inst_ext_name = inst_ext["name"]; |
| if (!inst_ext_name.isNull()) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "[%d]", j); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(inst_ext_name.asString()); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ICD Section"); |
| PrintTableElement("MISSING!"); |
| PrintEndTableRow(); |
| } |
| } |
| |
| stream->close(); |
| delete stream; |
| stream = NULL; |
| } |
| } |
| if (!found_registry || !found_json || !found_lib) { |
| failed = true; |
| } |
| |
| PrintEndTable(); |
| |
| if (failed) { |
| if (!found_registry) { |
| throw MISSING_DRIVER_REGISTRY; |
| } else if (!found_json) { |
| throw MISSING_DRIVER_JSON; |
| } else if (!found_lib) { |
| throw MISSING_DRIVER_LIB; |
| } else { |
| throw(-1); |
| } |
| } |
| } |
| |
| // Print out whatever Vulkan runtime information we can gather from the system |
| // via registry, standard system paths, etc. |
| void PrintRunTimeInfo(void) { |
| char generic_string[MAX_STRING_LENGTH]; |
| char count_string[MAX_STRING_LENGTH]; |
| char version_string[MAX_STRING_LENGTH]; |
| char output_string[MAX_STRING_LENGTH]; |
| char dll_search[MAX_STRING_LENGTH]; |
| char dll_prefix[MAX_STRING_LENGTH]; |
| uint32_t i = 0; |
| uint32_t install_count = 0; |
| FILE *fp = NULL; |
| |
| PrintBeginTable("Vulkan Runtimes", 3); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Runtimes In Registry"); |
| PrintTableElement(g_uninstall_reg_path); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // Find all Vulkan Runtime keys in the registry, and loop through each. |
| while (FindNextRegKey(HKEY_LOCAL_MACHINE, g_uninstall_reg_path, "VulkanRT", |
| i, MAX_STRING_LENGTH - 1, output_string)) { |
| snprintf(count_string, MAX_STRING_LENGTH - 1, "[%d]", i++); |
| |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%s\\%s", |
| g_uninstall_reg_path, output_string); |
| |
| // Get the version from the registry |
| if (ReadRegKeyString(HKEY_LOCAL_MACHINE, generic_string, |
| "DisplayVersion", MAX_STRING_LENGTH - 1, |
| version_string)) { |
| } else { |
| strncpy(version_string, output_string, MAX_STRING_LENGTH - 1); |
| } |
| |
| // Get the install count for this runtime from the registry |
| if (ReadRegKeyDword(HKEY_LOCAL_MACHINE, generic_string, "InstallCount", |
| &install_count)) { |
| snprintf(output_string, MAX_STRING_LENGTH - 1, |
| "%s [Install Count = %d]", version_string, install_count); |
| } else { |
| snprintf(output_string, MAX_STRING_LENGTH - 1, "%s", |
| version_string); |
| } |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(count_string, ALIGN_RIGHT); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } |
| |
| i = 0; |
| GetEnvironmentVariableA("SYSTEMROOT", generic_string, MAX_STRING_LENGTH); |
| #if _WIN64 || __x86_64__ || __ppc64__ |
| snprintf(dll_prefix, MAX_STRING_LENGTH - 1, "%s\\system32\\", |
| generic_string); |
| #else |
| if (global_items.is_wow64) { |
| snprintf(dll_prefix, MAX_STRING_LENGTH - 1, "%s\\sysWOW64\\", |
| generic_string); |
| } else { |
| snprintf(dll_prefix, MAX_STRING_LENGTH - 1, "%s\\system32\\", |
| generic_string); |
| } |
| #endif |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Runtimes in System Folder"); |
| PrintTableElement(dll_prefix); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| strncpy(dll_search, dll_prefix, MAX_STRING_LENGTH - 1); |
| strncat(dll_search, "Vulkan-*.dll", MAX_STRING_LENGTH - 1); |
| |
| WIN32_FIND_DATAA ffd; |
| HANDLE hFind = FindFirstFileA(dll_search, &ffd); |
| if (hFind != INVALID_HANDLE_VALUE) { |
| do { |
| if (0 == (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { |
| snprintf(count_string, MAX_STRING_LENGTH - 1, "DLL %d", i++); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(count_string, ALIGN_RIGHT); |
| PrintTableElement(ffd.cFileName); |
| |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%s\\%s", |
| dll_prefix, ffd.cFileName); |
| if (GetFileVersion(generic_string, MAX_STRING_LENGTH - 1, |
| version_string)) { |
| snprintf(output_string, MAX_STRING_LENGTH - 1, "Version %s", |
| version_string); |
| PrintTableElement(output_string); |
| } else { |
| PrintTableElement(""); |
| } |
| PrintEndTableRow(); |
| } |
| } while (FindNextFileA(hFind, &ffd) != 0); |
| FindClose(hFind); |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Runtime Used by App"); |
| if (!system("where vulkan-1.dll > where_vulkan")) { |
| fp = fopen("where_vulkan", "rt"); |
| if (NULL != fp) { |
| if (NULL != fgets(generic_string, MAX_STRING_LENGTH - 1, fp)) { |
| int i = (int)strlen(generic_string) - 1; |
| while (generic_string[i] == '\n' || generic_string[i] == '\r' || |
| generic_string[i] == '\t' || generic_string[i] == ' ') { |
| generic_string[i] = '\0'; |
| i--; |
| } |
| |
| if (GetFileVersion(generic_string, MAX_STRING_LENGTH - 1, |
| version_string)) { |
| PrintTableElement(generic_string); |
| PrintTableElement(version_string); |
| } else { |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| } |
| } |
| fclose(fp); |
| } |
| DeleteFileA("where_vulkan"); |
| } else { |
| PrintTableElement("Unknown"); |
| PrintTableElement("Unknown"); |
| } |
| PrintEndTableRow(); |
| |
| PrintEndTable(); |
| } |
| |
| // Print out information on whatever LunarG Vulkan SDKs we can find on |
| // the system using the registry, and environmental variables. This |
| // includes listing what layers are available from the SDK. |
| void PrintSDKInfo(void) { |
| const char vulkan_reg_base[] = "SOFTWARE\\Khronos\\Vulkan"; |
| const char vulkan_reg_base_wow64[] = |
| "SOFTWARE\\WOW6432Node\\Khronos\\Vulkan"; |
| char generic_string[MAX_STRING_LENGTH]; |
| char count_string[MAX_STRING_LENGTH]; |
| char output_string[MAX_STRING_LENGTH]; |
| char cur_vulkan_layer_json[MAX_STRING_LENGTH]; |
| char sdk_env_dir[MAX_STRING_LENGTH]; |
| char reg_key_loc[MAX_STRING_LENGTH]; |
| uint32_t i = 0; |
| uint32_t j = 0; |
| FILE *fp = NULL; |
| bool found = false; |
| bool failed = false; |
| |
| PrintBeginTable("LunarG Vulkan SDKs", 3); |
| PrintBeginTableRow(); |
| PrintTableElement("SDKs Found In Registry"); |
| PrintTableElement(g_uninstall_reg_path); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| while (FindNextRegKey(HKEY_LOCAL_MACHINE, g_uninstall_reg_path, "VulkanSDK", |
| i, MAX_STRING_LENGTH, output_string)) { |
| found = true; |
| snprintf(count_string, MAX_STRING_LENGTH - 1, "[%d]", i++); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%s\\%s", |
| g_uninstall_reg_path, output_string); |
| if (ReadRegKeyString(HKEY_LOCAL_MACHINE, generic_string, "InstallDir", |
| MAX_STRING_LENGTH, output_string)) { |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(count_string, ALIGN_RIGHT); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| } |
| if (!found) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("NONE FOUND", ALIGN_RIGHT); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| |
| if (0 != GetEnvironmentVariableA("VK_SDK_PATH", sdk_env_dir, |
| MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement("VK_SDK_PATH"); |
| global_items.sdk_found = true; |
| global_items.sdk_path = sdk_env_dir; |
| PrintTableElement(sdk_env_dir); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } else if (0 != GetEnvironmentVariableA("VULKAN_SDK", sdk_env_dir, |
| MAX_STRING_LENGTH - 1)) { |
| PrintBeginTableRow(); |
| PrintTableElement("VULKAN_SDK"); |
| global_items.sdk_found = true; |
| global_items.sdk_path = sdk_env_dir; |
| PrintTableElement(sdk_env_dir); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement("VK_SDK_PATH"); |
| PrintTableElement("No installed SDK"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| |
| #if _WIN64 || __x86_64__ || __ppc64__ |
| snprintf(reg_key_loc, MAX_STRING_LENGTH - 1, "%s\\ExplicitLayers", |
| vulkan_reg_base); |
| #else |
| if (global_items.is_wow64) { |
| snprintf(reg_key_loc, MAX_STRING_LENGTH - 1, "%s\\ExplicitLayers", |
| vulkan_reg_base_wow64); |
| } else { |
| snprintf(reg_key_loc, MAX_STRING_LENGTH - 1, "%s\\ExplicitLayers", |
| vulkan_reg_base); |
| } |
| #endif |
| |
| PrintBeginTableRow(); |
| PrintTableElement("SDK Explicit Layers"); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| found = false; |
| i = 0; |
| uint32_t returned_value = 0; |
| while (FindNextRegValue(HKEY_LOCAL_MACHINE, reg_key_loc, "", i, |
| MAX_STRING_LENGTH, cur_vulkan_layer_json, |
| &returned_value)) { |
| found = true; |
| |
| // Create a short json file name so we don't use up too much space |
| snprintf(output_string, MAX_STRING_LENGTH - 1, ".%s", |
| &cur_vulkan_layer_json[strlen(sdk_env_dir)]); |
| |
| snprintf(count_string, MAX_STRING_LENGTH - 1, "[%d]", i++); |
| PrintBeginTableRow(); |
| PrintTableElement(count_string, ALIGN_RIGHT); |
| PrintTableElement(output_string); |
| |
| snprintf(output_string, MAX_STRING_LENGTH - 1, "0x%08x", returned_value); |
| PrintTableElement(output_string); |
| PrintEndTableRow(); |
| |
| std::ifstream *stream = NULL; |
| stream = new std::ifstream(cur_vulkan_layer_json, std::ifstream::in); |
| if (nullptr == stream || stream->fail()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR reading JSON file!"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| Json::Value root = Json::nullValue; |
| Json::Reader reader; |
| if (!reader.parse(*stream, root, false) || root.isNull()) { |
| // Report to the user the failure and their locations in the |
| // document. |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR parsing JSON file!"); |
| PrintTableElement(reader.getFormattedErrorMessages()); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| PrintExplicitLayerJsonInfo(cur_vulkan_layer_json, root, 3); |
| } |
| |
| stream->close(); |
| delete stream; |
| stream = NULL; |
| } |
| } |
| if (!found) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("NONE FOUND", ALIGN_RIGHT); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| |
| PrintEndTable(); |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Print out whatever layers we can find out from the Windows' |
| // registry and other environmental variables that may be used |
| // to point the Vulkan loader at a layer path. |
| void PrintLayerInfo(void) { |
| const char vulkan_reg_base[] = "SOFTWARE\\Khronos\\Vulkan"; |
| const char vulkan_reg_base_wow64[] = |
| "SOFTWARE\\WOW6432Node\\Khronos\\Vulkan"; |
| char vulkan_impl_layer_reg_key[MAX_STRING_LENGTH]; |
| char cur_vulkan_layer_json[MAX_STRING_LENGTH]; |
| char generic_string[MAX_STRING_LENGTH]; |
| char full_layer_path[MAX_STRING_LENGTH]; |
| char env_value[MAX_STRING_LENGTH]; |
| uint32_t i = 0; |
| uint32_t j = 0; |
| FILE *fp = NULL; |
| bool failed = false; |
| |
| // Dump implicit layer information first. |
| #if _WIN64 || __x86_64__ || __ppc64__ |
| snprintf(vulkan_impl_layer_reg_key, MAX_STRING_LENGTH - 1, |
| "%s\\ImplicitLayers", vulkan_reg_base); |
| #else |
| if (global_items.is_wow64) { |
| snprintf(vulkan_impl_layer_reg_key, MAX_STRING_LENGTH - 1, |
| "%s\\ImplicitLayers", vulkan_reg_base_wow64); |
| } else { |
| snprintf(vulkan_impl_layer_reg_key, MAX_STRING_LENGTH - 1, |
| "%s\\ImplicitLayers", vulkan_reg_base); |
| } |
| #endif |
| |
| PrintBeginTable("Implicit Layers", 4); |
| PrintBeginTableRow(); |
| PrintTableElement("Registry"); |
| PrintTableElement(vulkan_impl_layer_reg_key); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // For each implicit layer listed in the registry, find its JSON and |
| // print out the useful information stored in it. |
| uint32_t returned_value = 0; |
| while (FindNextRegValue(HKEY_LOCAL_MACHINE, vulkan_impl_layer_reg_key, "", |
| i, MAX_STRING_LENGTH, cur_vulkan_layer_json, |
| &returned_value)) { |
| |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", i++); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(cur_vulkan_layer_json); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%08x", returned_value); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| std::ifstream *stream = NULL; |
| stream = new std::ifstream(cur_vulkan_layer_json, std::ifstream::in); |
| if (nullptr == stream || stream->fail()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR reading JSON file!"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| Json::Value root = Json::nullValue; |
| Json::Reader reader; |
| if (!reader.parse(*stream, root, false) || root.isNull()) { |
| // Report to the user the failure and their locations in the |
| // document. |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR parsing JSON file!"); |
| PrintTableElement(reader.getFormattedErrorMessages()); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| PrintImplicitLayerJsonInfo(cur_vulkan_layer_json, root); |
| } |
| |
| stream->close(); |
| delete stream; |
| stream = NULL; |
| } |
| } |
| PrintEndTable(); |
| |
| // If the user's system has VK_LAYER_PATH set, dump out the layer |
| // information found in that folder. This is important because if |
| // a user is having problems with the layers, they may be using |
| // non-standard layers. |
| if (0 != GetEnvironmentVariableA("VK_LAYER_PATH", env_value, |
| MAX_STRING_LENGTH - 1)) { |
| WIN32_FIND_DATAA ffd; |
| HANDLE hFind; |
| |
| PrintBeginTable("VK_LAYER_PATH Explicit Layers", 3); |
| PrintBeginTableRow(); |
| PrintTableElement("VK_LAYER_PATH"); |
| PrintTableElement(env_value); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // Look for any JSON files in that folder. |
| snprintf(full_layer_path, MAX_STRING_LENGTH - 1, "%s\\*.json", |
| env_value); |
| i = 0; |
| hFind = FindFirstFileA(full_layer_path, &ffd); |
| if (hFind != INVALID_HANDLE_VALUE) { |
| do { |
| if (0 == (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", |
| i++); |
| snprintf(cur_vulkan_layer_json, MAX_STRING_LENGTH - 1, |
| "%s\\%s", env_value, ffd.cFileName); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(ffd.cFileName); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| std::ifstream *stream = NULL; |
| stream = new std::ifstream(cur_vulkan_layer_json, |
| std::ifstream::in); |
| if (nullptr == stream || stream->fail()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR reading JSON file!"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| Json::Value root = Json::nullValue; |
| Json::Reader reader; |
| if (!reader.parse(*stream, root, false) || |
| root.isNull()) { |
| // Report to the user the failure and their |
| // locations in the document. |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR parsing JSON file!"); |
| PrintTableElement( |
| reader.getFormattedErrorMessages()); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| PrintExplicitLayerJsonInfo(cur_vulkan_layer_json, |
| root, 3); |
| } |
| |
| stream->close(); |
| delete stream; |
| stream = NULL; |
| } |
| } |
| } while (FindNextFileA(hFind, &ffd) != 0); |
| |
| FindClose(hFind); |
| } |
| |
| PrintEndTable(); |
| } |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| #elif __GNUC__ |
| |
| // Utility function to determine if a driver may exist in the folder. |
| bool CheckDriver(std::string &folder_loc, std::string &object_name) { |
| bool success = false; |
| std::string full_name = folder_loc; |
| if (folder_loc.c_str()[folder_loc.size() - 1] != '/') { |
| full_name += "/"; |
| } |
| full_name += object_name; |
| if (access(full_name.c_str(), R_OK) != -1) { |
| success = true; |
| } |
| return success; |
| } |
| |
| // Pointer to a function sed to validate if the system object is found |
| typedef bool (*PFN_CheckIfValid)(std::string &folder_loc, |
| std::string &object_name); |
| |
| bool FindLinuxSystemObject(std::string object_name, PFN_CheckIfValid func, |
| bool break_on_first) { |
| bool found_one = false; |
| std::string path_to_check; |
| char *env_value = getenv("LD_LIBRARY_PATH"); |
| |
| for (uint32_t iii = 0; iii < 5; iii++) { |
| switch (iii) { |
| case 0: |
| path_to_check = "/usr/lib"; |
| break; |
| case 1: |
| #if __x86_64__ || __ppc64__ |
| path_to_check = "/usr/lib/x86_64-linux-gnu"; |
| #else |
| path_to_check = "/usr/lib/i386-linux-gnu"; |
| #endif |
| break; |
| case 2: |
| #if __x86_64__ || __ppc64__ |
| path_to_check = "/usr/lib64"; |
| #else |
| path_to_check = "/usr/lib32"; |
| #endif |
| break; |
| case 3: |
| path_to_check = "/usr/local/lib"; |
| break; |
| case 4: |
| #if __x86_64__ || __ppc64__ |
| path_to_check = "/usr/local/lib64"; |
| #else |
| path_to_check = "/usr/local/lib32"; |
| #endif |
| break; |
| default: |
| continue; |
| } |
| |
| if (func(path_to_check, object_name)) { |
| // We found one runtime, clear any failures |
| found_one = true; |
| if (break_on_first) { |
| goto out; |
| } |
| } |
| } |
| |
| // LD_LIBRARY_PATH may have multiple folders listed in it (colon |
| // ':' delimited) |
| if (env_value != NULL) { |
| char *tok = strtok(env_value, ":"); |
| while (tok != NULL) { |
| path_to_check = tok; |
| if (func(path_to_check, object_name)) { |
| // We found one runtime, clear any failures |
| found_one = true; |
| } |
| tok = strtok(NULL, ":"); |
| } |
| } |
| |
| out: |
| return found_one; |
| } |
| |
| // Print out any information about the current system that we can |
| // capture to ease in debugging/investigation at a later time. |
| void PrintSystemInfo(void) { |
| FILE *fp; |
| char path[1035]; |
| char generic_string[MAX_STRING_LENGTH]; |
| utsname buffer; |
| struct statvfs fs_stats; |
| int num_cpus; |
| uint64_t memory; |
| char *env_value; |
| bool failed = false; |
| std::string cur_directory; |
| std::string exe_directory; |
| std::string desktop_session; |
| |
| BeginSection("System Info"); |
| |
| // Environment section has information about the OS and the |
| // execution environment. |
| PrintBeginTable("Environment", 3); |
| |
| fp = popen("cat /etc/os-release", "r"); |
| if (fp == NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement("ERROR"); |
| PrintTableElement("Failed to cat /etc/os-release"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| // Read the output a line at a time - output it. |
| while (fgets(path, sizeof(path) - 1, fp) != NULL) { |
| if (NULL != strstr(path, "PRETTY_NAME")) { |
| uint32_t index; |
| index = strlen(path) - 1; |
| while (path[index] == ' ' || path[index] == '\t' || |
| path[index] == '\r' || path[index] == '\n' || |
| path[index] == '\"') { |
| path[index] = '\0'; |
| index = strlen(path) - 1; |
| } |
| index = 13; |
| while (path[index] == ' ' || path[index] == '\t' || |
| path[index] == '\"') { |
| index++; |
| } |
| PrintBeginTableRow(); |
| PrintTableElement("Linux"); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Distro"); |
| PrintTableElement(&path[index]); |
| PrintEndTableRow(); |
| break; |
| } |
| } |
| pclose(fp); |
| } |
| |
| errno = 0; |
| if (uname(&buffer) != 0) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR"); |
| PrintTableElement("Failed to query uname"); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Kernel Build"); |
| PrintTableElement(buffer.release); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Machine Target"); |
| PrintTableElement(buffer.machine); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Version"); |
| PrintTableElement(buffer.version); |
| PrintEndTableRow(); |
| } |
| |
| env_value = getenv("DESKTOP_SESSION"); |
| if (env_value != NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("DESKTOP_SESSION"); |
| PrintTableElement(env_value); |
| PrintEndTableRow(); |
| |
| desktop_session = env_value; |
| } |
| env_value = getenv("LD_LIBRARY_PATH"); |
| if (env_value != NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("LD_LIBRARY_PATH"); |
| PrintTableElement(env_value); |
| PrintEndTableRow(); |
| } |
| env_value = getenv("GDK_BACKEND"); |
| if (env_value != NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("GDK_BACKEND"); |
| PrintTableElement(env_value); |
| PrintEndTableRow(); |
| } |
| env_value = getenv("DISPLAY"); |
| if (env_value != NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("DISPLAY"); |
| PrintTableElement(env_value); |
| PrintEndTableRow(); |
| } |
| env_value = getenv("WAYLAND_DISPLAY"); |
| if (env_value != NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("WAYLAND_DISPLAY"); |
| PrintTableElement(env_value); |
| PrintEndTableRow(); |
| } |
| env_value = getenv("MIR_SOCKET"); |
| if (env_value != NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("MIR_SOCKET"); |
| PrintTableElement(env_value); |
| PrintEndTableRow(); |
| } |
| |
| PrintEndTable(); |
| |
| // Output whatever generic hardware information we can find out about the |
| // system. Including how much memory and disk space is available. |
| PrintBeginTable("Hardware", 3); |
| |
| num_cpus = sysconf(_SC_NPROCESSORS_ONLN); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", num_cpus); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("CPUs"); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| memory = (sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGE_SIZE)) >> 10; |
| if ((memory >> 10) > 0) { |
| memory >>= 10; |
| if ((memory >> 20) > 0) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u TB", |
| static_cast<uint32_t>(memory >> 20)); |
| } else if ((memory >> 10) > 0) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u GB", |
| static_cast<uint32_t>(memory >> 10)); |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u MB", |
| static_cast<uint32_t>(memory)); |
| } |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u KB", |
| static_cast<uint32_t>(memory)); |
| } |
| PrintBeginTableRow(); |
| PrintTableElement("Memory"); |
| PrintTableElement("Physical"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| if (0 == statvfs("/etc/os-release", &fs_stats)) { |
| uint64_t bytes_total = |
| (uint64_t)fs_stats.f_bsize * (uint64_t)fs_stats.f_bavail; |
| if ((bytes_total >> 40) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u TB", |
| static_cast<uint32_t>(bytes_total >> 40)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((bytes_total >> 30) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u GB", |
| static_cast<uint32_t>(bytes_total >> 30)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| } else if ((bytes_total >> 20) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u MB", |
| static_cast<uint32_t>(bytes_total >> 20)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else if ((bytes_total >> 10) > 0x0ULL) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u KB", |
| static_cast<uint32_t>(bytes_total >> 10)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%u bytes", |
| static_cast<uint32_t>(bytes_total)); |
| PrintBeginTableRow(); |
| PrintTableElement("Disk Space"); |
| PrintTableElement("Free"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } |
| PrintEndTable(); |
| |
| // Print out information about this executable. |
| PrintBeginTable("Executable", 2); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Exe Directory"); |
| PrintTableElement(global_items.exe_directory); |
| PrintEndTableRow(); |
| |
| if (getcwd(generic_string, MAX_STRING_LENGTH - 1) != NULL) { |
| cur_directory = generic_string; |
| PrintBeginTableRow(); |
| PrintTableElement("Current Directory"); |
| PrintTableElement(cur_directory); |
| PrintEndTableRow(); |
| } else { |
| cur_directory = ""; |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement("App Version"); |
| PrintTableElement(APP_VERSION); |
| PrintEndTableRow(); |
| |
| uint32_t major = VK_VERSION_MAJOR(VK_API_VERSION_1_0); |
| uint32_t minor = VK_VERSION_MINOR(VK_API_VERSION_1_0); |
| uint32_t patch = VK_VERSION_PATCH(VK_HEADER_VERSION); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d.%d.%d", major, minor, |
| patch); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Vulkan API Version"); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Byte Format"); |
| #if __x86_64__ || __ppc64__ |
| PrintTableElement("64-bit"); |
| #else |
| PrintTableElement("32-bit"); |
| #endif |
| PrintEndTableRow(); |
| |
| PrintEndTable(); |
| |
| // Print out the rest of the useful system information. |
| PrintDriverInfo(); |
| PrintRunTimeInfo(); |
| PrintSDKInfo(); |
| PrintLayerInfo(); |
| PrintLayerSettingsFileInfo(); |
| EndSection(); |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Print out the information for every driver JSON in the appropriate |
| // system folders. |
| void PrintDriverInfo(void) { |
| bool failed = false; |
| char generic_string[MAX_STRING_LENGTH]; |
| char full_driver_path[MAX_STRING_LENGTH]; |
| uint32_t i = 0; |
| uint32_t j = 0; |
| bool found_json = false; |
| bool found_lib = false; |
| char *env_value = NULL; |
| |
| PrintBeginTable("Vulkan Driver Info", 3); |
| |
| // There are several folders ICD JSONs could be in. So, |
| // try all of them. |
| for (uint32_t dir = 0; dir < 6; dir++) { |
| std::string cur_driver_path; |
| std::string cur_driver_json; |
| switch (dir) { |
| case 0: |
| cur_driver_path = "/etc/vulkan/icd.d"; |
| break; |
| case 1: |
| cur_driver_path = "/usr/share/vulkan/icd.d"; |
| break; |
| case 2: |
| cur_driver_path = "/usr/local/etc/vulkan/icd.d"; |
| break; |
| case 3: |
| cur_driver_path = "/usr/local/share/vulkan/icd.d"; |
| break; |
| case 4: |
| env_value = getenv("HOME"); |
| if (NULL == env_value) { |
| cur_driver_path = "~/.local/share/vulkan/icd.d"; |
| } else { |
| cur_driver_path = env_value; |
| cur_driver_path += "/.local/share/vulkan/icd.d"; |
| } |
| break; |
| case 5: |
| env_value = getenv("VK_DRIVERS_PATH"); |
| if (NULL == env_value) { |
| continue; |
| } |
| cur_driver_path = env_value; |
| break; |
| default: |
| continue; |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement(cur_driver_path.c_str()); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // Loop through each JSON file found in the current |
| // location. |
| DIR *layer_dir = opendir(cur_driver_path.c_str()); |
| if (NULL == layer_dir) { |
| continue; |
| } |
| dirent *cur_ent; |
| i = 0; |
| while ((cur_ent = readdir(layer_dir)) != NULL) { |
| if (NULL != strstr(cur_ent->d_name, ".json")) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", i++); |
| cur_driver_json = cur_driver_path; |
| cur_driver_json += "/"; |
| cur_driver_json += cur_ent->d_name; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(cur_ent->d_name); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| bool found_lib_this_time = false; |
| std::ifstream *stream = NULL; |
| stream = new std::ifstream(cur_driver_json.c_str(), |
| std::ifstream::in); |
| if (nullptr == stream || stream->fail()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Error reading JSON file"); |
| PrintTableElement(cur_driver_json); |
| PrintEndTableRow(); |
| |
| failed = true; |
| continue; |
| } else { |
| Json::Value root = Json::nullValue; |
| Json::Reader reader; |
| if (!reader.parse(*stream, root, false) || root.isNull()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Error reading JSON file"); |
| PrintTableElement(reader.getFormattedErrorMessages()); |
| PrintEndTableRow(); |
| |
| failed = true; |
| stream->close(); |
| delete stream; |
| continue; |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("JSON File Version"); |
| if (!root["file_format_version"].isNull()) { |
| PrintTableElement( |
| root["file_format_version"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| PrintEndTableRow(); |
| |
| if (!root["ICD"].isNull()) { |
| found_json = true; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("API Version"); |
| if (!root["ICD"]["api_version"].isNull()) { |
| PrintTableElement( |
| root["ICD"]["api_version"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Library Path"); |
| if (!root["ICD"]["library_path"].isNull()) { |
| std::string driver_name = root["ICD"]["library_path"].asString(); |
| PrintTableElement(driver_name); |
| PrintEndTableRow(); |
| |
| if (GenerateLibraryPath( |
| cur_driver_json.c_str(), |
| driver_name.c_str(), |
| MAX_STRING_LENGTH, full_driver_path)) { |
| // First try the generated path. |
| if (access(full_driver_path, R_OK) != -1) { |
| found_lib_this_time = true; |
| } else if (driver_name.find("/") == std::string::npos) { |
| if (FindLinuxSystemObject(driver_name, |
| CheckDriver, |
| true)) { |
| found_lib_this_time = true; |
| } |
| } |
| if (!found_lib_this_time) { |
| snprintf(generic_string, |
| MAX_STRING_LENGTH - 1, |
| "Failed to find driver %s " |
| "referenced by JSON %s", |
| full_driver_path, |
| cur_driver_json.c_str()); |
| } else { |
| found_lib = true; |
| } |
| } else { |
| snprintf(generic_string, |
| MAX_STRING_LENGTH - 1, |
| "Failed to find driver %s " |
| "referenced by JSON %s", |
| full_driver_path, |
| cur_driver_json.c_str()); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } else { |
| PrintTableElement("MISSING!"); |
| PrintEndTableRow(); |
| } |
| |
| char count_str[MAX_STRING_LENGTH]; |
| j = 0; |
| Json::Value dev_exts = |
| root["ICD"]["device_extensions"]; |
| if (!dev_exts.isNull() && dev_exts.isArray()) { |
| snprintf(count_str, MAX_STRING_LENGTH - 1, "%d", |
| dev_exts.size()); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Device Extensions"); |
| PrintTableElement(count_str); |
| PrintEndTableRow(); |
| |
| for (Json::ValueIterator dev_ext_it = |
| dev_exts.begin(); |
| dev_ext_it != dev_exts.end(); |
| dev_ext_it++) { |
| Json::Value dev_ext = (*dev_ext_it); |
| Json::Value dev_ext_name = dev_ext["name"]; |
| if (!dev_ext_name.isNull()) { |
| snprintf(generic_string, |
| MAX_STRING_LENGTH - 1, "[%d]", |
| j); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(generic_string, |
| ALIGN_RIGHT); |
| PrintTableElement( |
| dev_ext_name.asString()); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| Json::Value inst_exts = |
| root["ICD"]["instance_extensions"]; |
| j = 0; |
| if (!inst_exts.isNull() && inst_exts.isArray()) { |
| snprintf(count_str, MAX_STRING_LENGTH - 1, "%d", |
| inst_exts.size()); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Instance Extensions"); |
| PrintTableElement(count_str); |
| PrintEndTableRow(); |
| |
| for (Json::ValueIterator inst_ext_it = |
| |
| inst_exts.begin(); |
| inst_ext_it != inst_exts.end(); |
| inst_ext_it++) { |
| Json::Value inst_ext = (*inst_ext_it); |
| Json::Value inst_ext_name = |
| inst_ext["name"]; |
| if (!inst_ext_name.isNull()) { |
| snprintf(generic_string, |
| MAX_STRING_LENGTH - 1, "[%d]", |
| j); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(generic_string, |
| ALIGN_RIGHT); |
| PrintTableElement( |
| inst_ext_name.asString()); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ICD Section"); |
| PrintTableElement("MISSING!"); |
| PrintEndTableRow(); |
| } |
| } |
| |
| stream->close(); |
| delete stream; |
| stream = NULL; |
| } |
| } |
| } |
| } |
| if (!found_json || !found_lib) { |
| failed = true; |
| } |
| PrintEndTable(); |
| if (failed) { |
| if (!found_json) { |
| throw MISSING_DRIVER_JSON; |
| } else if (!found_lib) { |
| throw MISSING_DRIVER_LIB; |
| } else { |
| throw(-1); |
| } |
| } |
| } |
| |
| // Print out all the runtime files found in a given location. This way we |
| // capture the full state of the system. |
| bool PrintRuntimesInFolder(std::string &folder_loc, std::string &object_name, bool print_header = true) { |
| DIR *runtime_dir; |
| bool success = false; |
| bool failed = false; |
| |
| runtime_dir = opendir(folder_loc.c_str()); |
| if (NULL != runtime_dir) { |
| bool file_found = false; |
| FILE *pfp; |
| uint32_t i = 0; |
| dirent *cur_ent; |
| std::string command_str; |
| std::stringstream generic_str; |
| char path[1035]; |
| |
| if (print_header) { |
| PrintBeginTableRow(); |
| PrintTableElement(folder_loc, ALIGN_RIGHT); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| |
| while ((cur_ent = readdir(runtime_dir)) != NULL) { |
| if (NULL != strstr(cur_ent->d_name, object_name.c_str()) && |
| strlen(cur_ent->d_name) == 14) { |
| |
| // Get the source of this symbolic link |
| command_str = "stat -c%N "; |
| command_str += folder_loc; |
| command_str += "/"; |
| command_str += cur_ent->d_name; |
| pfp = popen(command_str.c_str(), "r"); |
| |
| generic_str << "[" << i++ << "]"; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(generic_str.str(), ALIGN_RIGHT); |
| |
| file_found = true; |
| |
| if (pfp == NULL) { |
| PrintTableElement(cur_ent->d_name); |
| PrintTableElement("Failed to retrieve symbolic link"); |
| failed = true; |
| } else { |
| if (NULL != fgets(path, sizeof(path) - 1, pfp)) { |
| std::string cmd = path; |
| size_t arrow_loc = cmd.find("->"); |
| if (arrow_loc == std::string::npos) { |
| std::string trimmed_path = |
| TrimWhitespace(path, " \t\n\r\'\""); |
| |
| PrintTableElement(trimmed_path); |
| PrintTableElement(""); |
| } else { |
| std::string before_arrow = cmd.substr(0, arrow_loc); |
| std::string trim_before = |
| TrimWhitespace(before_arrow, " \t\n\r\'\""); |
| std::string after_arrow = |
| cmd.substr(arrow_loc + 2, std::string::npos); |
| std::string trim_after = |
| TrimWhitespace(after_arrow, " \t\n\r\'\""); |
| PrintTableElement(trim_before); |
| PrintTableElement(trim_after); |
| } |
| } else { |
| PrintTableElement(cur_ent->d_name); |
| PrintTableElement("Failed to retrieve symbolic link"); |
| } |
| |
| PrintEndTableRow(); |
| |
| pclose(pfp); |
| } |
| } |
| } |
| if (!file_found) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("No libvulkan.so files found"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| closedir(runtime_dir); |
| |
| success = !failed; |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(folder_loc, ALIGN_RIGHT); |
| PrintTableElement("No such folder"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| |
| return success; |
| } |
| |
| // Utility function to determine if a runtime exists in the folder |
| bool CheckRuntime(std::string &folder_loc, std::string &object_name) { |
| return PrintRuntimesInFolder(folder_loc, object_name); |
| } |
| |
| // Print out whatever Vulkan runtime information we can gather from the |
| // standard system paths, etc. |
| void PrintRunTimeInfo(void) { |
| const char vulkan_so_prefix[] = "libvulkan.so."; |
| char path[1035]; |
| char generic_string[MAX_STRING_LENGTH]; |
| char buff[PATH_MAX]; |
| std::string runtime_dir_name; |
| FILE *pfp; |
| bool failed = false; |
| PrintBeginTable("Vulkan Runtimes", 3); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("Possible Runtime Folders"); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| if (!FindLinuxSystemObject(vulkan_so_prefix, CheckRuntime, false)) { |
| failed = true; |
| } |
| |
| ssize_t len = ::readlink("/proc/self/exe", buff, sizeof(buff) - 1); |
| if (len != -1) { |
| buff[len] = '\0'; |
| |
| std::string runtime_dir_id = "Runtime Folder Used By via"; |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "ldd %s", buff); |
| pfp = popen(generic_string, "r"); |
| if (pfp == NULL) { |
| PrintBeginTableRow(); |
| PrintTableElement(runtime_dir_id); |
| PrintTableElement("Failed to query via library info"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| bool found = false; |
| while (fgets(path, sizeof(path) - 1, pfp) != NULL) { |
| if (NULL != strstr(path, vulkan_so_prefix)) { |
| std::string cmd = path; |
| size_t arrow_loc = cmd.find("=>"); |
| if (arrow_loc == std::string::npos) { |
| std::string trimmed_path = |
| TrimWhitespace(path, " \t\n\r\'\""); |
| PrintBeginTableRow(); |
| PrintTableElement(runtime_dir_id); |
| PrintTableElement(trimmed_path); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } else { |
| std::string after_arrow = cmd.substr(arrow_loc + 2); |
| std::string before_slash = |
| after_arrow.substr(0, after_arrow.rfind("/")); |
| std::string trimmed = |
| TrimWhitespace(before_slash, " \t\n\r\'\""); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(runtime_dir_id); |
| PrintTableElement(trimmed); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| std::string find_so = vulkan_so_prefix; |
| if (!PrintRuntimesInFolder(trimmed, find_so, false)) { |
| failed = true; |
| } else { |
| // We found one runtime, clear any failures |
| if (failed) { |
| failed = false; |
| } |
| } |
| } |
| found = !failed; |
| break; |
| } |
| } |
| if (!found) { |
| PrintBeginTableRow(); |
| PrintTableElement(runtime_dir_id); |
| PrintTableElement( |
| "Failed to find Vulkan SO used for via"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| pclose(pfp); |
| } |
| PrintEndTableRow(); |
| } |
| |
| PrintEndTable(); |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Print out the explicit layers that are stored in any of the standard |
| // locations. |
| bool PrintExplicitLayersInFolder(std::string &id, std::string &folder_loc) { |
| DIR *layer_dir; |
| bool success = false; |
| |
| layer_dir = opendir(folder_loc.c_str()); |
| if (NULL != layer_dir) { |
| dirent *cur_ent; |
| std::string cur_layer; |
| char generic_string[MAX_STRING_LENGTH]; |
| uint32_t i = 0; |
| bool failed = false; |
| bool found_json = false; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(id); |
| PrintTableElement(folder_loc); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // Loop through each JSON in a given folder |
| while ((cur_ent = readdir(layer_dir)) != NULL) { |
| if (NULL != strstr(cur_ent->d_name, ".json")) { |
| found_json = true; |
| |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", i++); |
| cur_layer = folder_loc; |
| cur_layer += "/"; |
| cur_layer += cur_ent->d_name; |
| |
| // Parse the JSON file |
| std::ifstream *stream = NULL; |
| stream = new std::ifstream(cur_layer, std::ifstream::in); |
| if (nullptr == stream || stream->fail()) { |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(cur_ent->d_name); |
| PrintTableElement("ERROR reading JSON file!"); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| Json::Value root = Json::nullValue; |
| Json::Reader reader; |
| if (!reader.parse(*stream, root, false) || root.isNull()) { |
| // Report to the user the failure and their |
| // locations in the document. |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(cur_ent->d_name); |
| PrintTableElement(reader.getFormattedErrorMessages()); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(cur_ent->d_name); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // Dump out the standard explicit layer information. |
| PrintExplicitLayerJsonInfo(cur_layer.c_str(), root, 3); |
| } |
| |
| stream->close(); |
| delete stream; |
| stream = NULL; |
| } |
| } |
| } |
| if (!found_json) { |
| PrintBeginTableRow(); |
| PrintTableElement(id); |
| PrintTableElement(folder_loc); |
| PrintTableElement("No JSON files found"); |
| PrintEndTableRow(); |
| } |
| closedir(layer_dir); |
| |
| success = !failed; |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(id); |
| PrintTableElement(folder_loc); |
| PrintTableElement("No such folder"); |
| PrintEndTableRow(); |
| |
| // This isn't a failure, just an attempt to read information |
| success = true; |
| } |
| |
| return success; |
| } |
| |
| // Print out information on whatever LunarG Vulkan SDKs we can find on |
| // the system using the standard locations and environmental variables. |
| // This includes listing what layers are available from the SDK. |
| void PrintSDKInfo(void) { |
| bool failed = false; |
| bool sdk_exists = false; |
| std::string sdk_path; |
| std::string sdk_env_name; |
| const char vulkan_so_prefix[] = "libvulkan.so."; |
| DIR *sdk_dir; |
| dirent *cur_ent; |
| char *env_value; |
| |
| PrintBeginTable("LunarG Vulkan SDKs", 3); |
| |
| for (uint32_t dir = 0; dir < 2; dir++) { |
| switch (dir) { |
| case 0: |
| sdk_env_name = "VK_SDK_PATH"; |
| env_value = getenv(sdk_env_name.c_str()); |
| if (env_value == NULL) { |
| continue; |
| } |
| sdk_path = env_value; |
| break; |
| case 1: |
| sdk_env_name = "VULKAN_SDK"; |
| env_value = getenv(sdk_env_name.c_str()); |
| if (env_value == NULL) { |
| continue; |
| } |
| sdk_path = env_value; |
| break; |
| default: |
| failed = true; |
| continue; |
| } |
| |
| std::string explicit_layer_path = sdk_path; |
| explicit_layer_path += "/etc/explicit_layer.d"; |
| |
| sdk_dir = opendir(explicit_layer_path.c_str()); |
| if (NULL != sdk_dir) { |
| while ((cur_ent = readdir(sdk_dir)) != NULL) { |
| if (NULL != strstr(cur_ent->d_name, vulkan_so_prefix) && |
| strlen(cur_ent->d_name) == 14) { |
| } |
| } |
| closedir(sdk_dir); |
| |
| if (!PrintExplicitLayersInFolder(sdk_env_name, |
| explicit_layer_path)) { |
| failed = true; |
| } |
| |
| global_items.sdk_found = true; |
| global_items.sdk_path = sdk_path; |
| sdk_exists = true; |
| } |
| } |
| |
| if (!sdk_exists) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("No installed SDKs found"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| |
| PrintEndTable(); |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Print out whatever layers we can find out from other environmental |
| // variables that may be used to point the Vulkan loader at a layer path. |
| void PrintLayerInfo(void) { |
| uint32_t i = 0; |
| char generic_string[MAX_STRING_LENGTH]; |
| bool failed = false; |
| char cur_vulkan_layer_json[MAX_STRING_LENGTH]; |
| DIR *layer_dir; |
| dirent *cur_ent; |
| std::string layer_path; |
| char *env_value = NULL; |
| |
| // Dump out implicit layer information first |
| PrintBeginTable("Implicit Layers", 3); |
| |
| // There are several folders implicit layers could be in. So, |
| // try all of them. |
| for (uint32_t dir = 0; dir < 5; dir++) { |
| std::string cur_layer_path; |
| switch (dir) { |
| case 0: |
| cur_layer_path = "/etc/vulkan/implicit_layer.d"; |
| break; |
| case 1: |
| cur_layer_path = "/usr/share/vulkan/implicit_layer.d"; |
| break; |
| case 2: |
| cur_layer_path = "/usr/local/etc/vulkan/implicit_layer.d"; |
| break; |
| case 3: |
| cur_layer_path = "/usr/local/share/vulkan/implicit_layer.d"; |
| break; |
| case 4: |
| env_value = getenv("HOME"); |
| if (NULL == env_value) { |
| cur_layer_path = "~/.local/share/vulkan/implicit_layer.d"; |
| } else { |
| cur_layer_path = env_value; |
| cur_layer_path += "/.local/share/vulkan/implicit_layer.d"; |
| } |
| break; |
| default: |
| continue; |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement(cur_layer_path); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| layer_dir = opendir(cur_layer_path.c_str()); |
| if (NULL != layer_dir) { |
| while ((cur_ent = readdir(layer_dir)) != NULL) { |
| if (NULL != strstr(cur_ent->d_name, ".json")) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", i++); |
| snprintf(cur_vulkan_layer_json, MAX_STRING_LENGTH - 1, "%s/%s", |
| cur_layer_path.c_str(), cur_ent->d_name); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(cur_ent->d_name); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| std::ifstream *stream = NULL; |
| stream = |
| new std::ifstream(cur_vulkan_layer_json, std::ifstream::in); |
| if (nullptr == stream || stream->fail()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR reading JSON file!"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| Json::Value root = Json::nullValue; |
| Json::Reader reader; |
| if (!reader.parse(*stream, root, false) || root.isNull()) { |
| // Report to the user the failure and their |
| // locations in the document. |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("ERROR parsing JSON file!"); |
| PrintTableElement(reader.getFormattedErrorMessages()); |
| PrintEndTableRow(); |
| failed = true; |
| } else { |
| PrintExplicitLayerJsonInfo(cur_vulkan_layer_json, root, |
| 3); |
| } |
| |
| stream->close(); |
| delete stream; |
| stream = NULL; |
| } |
| } |
| } |
| closedir(layer_dir); |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Directory does not exist"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| } |
| PrintEndTable(); |
| |
| // Dump out any explicit layer information. |
| PrintBeginTable("Explicit Layers", 3); |
| |
| // There are several folders explicit layers could be in. So, |
| // try all of them. |
| for (uint32_t dir = 0; dir < 6; dir++) { |
| std::string cur_layer_path; |
| std::string explicit_layer_id; |
| std::string explicit_layer_path = cur_layer_path; |
| char *env_value = NULL; |
| switch (dir) { |
| case 0: |
| cur_layer_path = "/etc/vulkan/explicit_layer.d"; |
| explicit_layer_id = "/etc/vulkan"; |
| break; |
| case 1: |
| cur_layer_path = "/usr/share/vulkan/explicit_layer.d"; |
| explicit_layer_id = "/usr/share/vulkan"; |
| break; |
| case 2: |
| cur_layer_path = "/usr/local/etc/vulkan/explicit_layer.d"; |
| explicit_layer_id = "/usr/local/etc/vulkan"; |
| break; |
| case 3: |
| cur_layer_path = "/usr/local/share/vulkan/explicit_layer.d"; |
| explicit_layer_id = "/usr/local/share/vulkan"; |
| break; |
| case 4: |
| explicit_layer_id = "$HOME/.local/share/vulkan/explicit_layer.d"; |
| env_value = getenv("HOME"); |
| if (NULL == env_value) { |
| cur_layer_path = "~/.local/share/vulkan/explicit_layer.d"; |
| } else { |
| cur_layer_path = env_value; |
| cur_layer_path += "/.local/share/vulkan/explicit_layer.d"; |
| } |
| break; |
| case 5: |
| explicit_layer_id = "VK_LAYER_PATH"; |
| env_value = getenv("VK_LAYER_PATH"); |
| if (NULL == env_value) { |
| continue; |
| } |
| cur_layer_path = env_value; |
| break; |
| default: |
| continue; |
| } |
| |
| PrintExplicitLayersInFolder(explicit_layer_id, cur_layer_path); |
| } |
| |
| PrintEndTable(); |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Run the test in the specified directory with the corresponding |
| // command-line arguments. |
| // Returns 0 on no error, 1 if test file wasn't found, and -1 |
| // on any other errors. |
| int RunTestInDirectory(std::string path, std::string test, |
| std::string cmd_line) { |
| char orig_dir[MAX_STRING_LENGTH]; |
| int err_code = -1; |
| orig_dir[0] = '\0'; |
| if (NULL != getcwd(orig_dir, MAX_STRING_LENGTH - 1)) { |
| int err = chdir(path.c_str()); |
| if (-1 != err) { |
| if (-1 != access(test.c_str(), X_OK)) { |
| printf("cmd_line - %s\n", cmd_line.c_str()); |
| err_code = system(cmd_line.c_str()); |
| } else { |
| // Can't run because it's either not there or an actual |
| // exe. So, just return a separate error code. |
| err_code = 1; |
| } |
| } else { |
| // Path doesn't exist at all |
| err_code = 1; |
| } |
| chdir(orig_dir); |
| } |
| return err_code; |
| } |
| |
| #endif |
| |
| // Following functions should be OS agnostic: |
| //========================================== |
| |
| // Trim any whitespace preceeding or following the actual |
| // content inside of a string. The actual items labeled |
| // as whitespace are passed in as the second set of |
| // parameters. |
| std::string TrimWhitespace(const std::string &str, |
| const std::string &whitespace) { |
| const auto strBegin = str.find_first_not_of(whitespace); |
| if (strBegin == std::string::npos) { |
| return ""; // no content |
| } |
| |
| const auto strEnd = str.find_last_not_of(whitespace); |
| const auto strRange = strEnd - strBegin + 1; |
| |
| return str.substr(strBegin, strRange); |
| } |
| |
| // Print any information found on the current vk_layer_settings.txt |
| // file being used. It looks in the current folder first, and then will |
| // look in any defined by the registry variable VK_LAYER_SETTINGS_PATH. |
| void PrintLayerSettingsFileInfo(void) { |
| bool failed = false; |
| char *settings_path = NULL; |
| std::string settings_file; |
| std::map<std::string, std::vector<SettingPair>> settings; |
| |
| PrintBeginTable("Layer Settings File", 4); |
| |
| // If the settings path environment variable is set, use that. |
| #ifdef _WIN32 |
| char generic_string[MAX_STRING_LENGTH]; |
| if (0 != GetEnvironmentVariableA("VK_LAYER_SETTINGS_PATH", generic_string, |
| MAX_STRING_LENGTH - 1)) { |
| settings_path = generic_string; |
| settings_file = settings_path; |
| settings_file += '\\'; |
| } |
| #else |
| settings_path = getenv("VK_LAYER_SETTINGS_PATH"); |
| if (NULL != settings_path) { |
| settings_file = settings_path; |
| settings_file += '/'; |
| } |
| #endif |
| settings_file += "vk_layer_settings.txt"; |
| |
| PrintBeginTableRow(); |
| PrintTableElement("VK_LAYER_SETTINGS_PATH"); |
| if (NULL != settings_path) { |
| PrintTableElement(settings_path); |
| } else { |
| PrintTableElement("Not Defined"); |
| } |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // Load the file from the appropriate location |
| PrintBeginTableRow(); |
| PrintTableElement("Settings File"); |
| PrintTableElement("vk_layer_settings.txt"); |
| std::ifstream *settings_stream = |
| new std::ifstream(settings_file, std::ifstream::in); |
| if (nullptr == settings_stream || settings_stream->fail()) { |
| // No file was found. This is NOT an error. |
| PrintTableElement("Not Found"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } else { |
| // We found a file, so parse it. |
| PrintTableElement("Found"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // The settings file is a text file where: |
| // - # indicates a comment |
| // - Settings are stored in the fasion: |
| // <layer_name>.<setting> = <value> |
| while (settings_stream->good()) { |
| std::string cur_line; |
| getline(*settings_stream, cur_line); |
| std::string trimmed_line = TrimWhitespace(cur_line); |
| |
| // Skip blank and comment lines |
| if (trimmed_line.length() == 0 || trimmed_line.c_str()[0] == '#') { |
| continue; |
| } |
| |
| // If no equal, treat as unknown |
| size_t equal_loc = trimmed_line.find("="); |
| if (equal_loc == std::string::npos) { |
| continue; |
| } |
| |
| SettingPair new_pair; |
| |
| std::string before_equal = trimmed_line.substr(0, equal_loc); |
| std::string after_equal = |
| trimmed_line.substr(equal_loc + 1, std::string::npos); |
| new_pair.value = TrimWhitespace(after_equal); |
| |
| std::string trimmed_setting = TrimWhitespace(before_equal); |
| |
| // Look for period |
| std::string setting_layer = "--None--"; |
| std::string setting_name = ""; |
| size_t period_loc = trimmed_setting.find("."); |
| if (period_loc == std::string::npos) { |
| setting_name = trimmed_setting; |
| } else { |
| setting_layer = trimmed_setting.substr(0, period_loc); |
| setting_name = |
| trimmed_setting.substr(period_loc + 1, std::string::npos); |
| } |
| new_pair.name = setting_name; |
| |
| // Add items to settings map for now |
| if (settings.find(setting_layer) == settings.end()) { |
| // Not found |
| std::vector<SettingPair> new_vector; |
| new_vector.push_back(new_pair); |
| settings[setting_layer] = new_vector; |
| } else { |
| // Already exists |
| std::vector<SettingPair> &cur_vector = settings[setting_layer]; |
| cur_vector.push_back(new_pair); |
| } |
| } |
| |
| // Now that all items have been grouped in the settings map |
| // appropriately, print |
| // them out |
| for (auto layer_iter = settings.begin(); layer_iter != settings.end(); |
| layer_iter++) { |
| std::vector<SettingPair> &cur_vector = layer_iter->second; |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(layer_iter->first, ALIGN_RIGHT); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| for (uint32_t cur_item = 0; cur_item < cur_vector.size(); |
| cur_item++) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement(cur_vector[cur_item].name); |
| PrintTableElement(cur_vector[cur_item].value); |
| PrintEndTableRow(); |
| } |
| } |
| |
| settings_stream->close(); |
| delete settings_stream; |
| } |
| PrintEndTable(); |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Print out the information stored in an explicit layer's JSON file. |
| void PrintExplicitLayerJsonInfo(const char *layer_json_filename, |
| Json::Value root, uint32_t num_cols) { |
| char generic_string[MAX_STRING_LENGTH]; |
| uint32_t cur_col; |
| uint32_t ext; |
| if (!root["layer"].isNull()) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Name"); |
| if (!root["layer"]["name"].isNull()) { |
| PrintTableElement(root["layer"]["name"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Description"); |
| if (!root["layer"]["description"].isNull()) { |
| PrintTableElement(root["layer"]["description"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("API Version"); |
| if (!root["layer"]["api_version"].isNull()) { |
| PrintTableElement(root["layer"]["api_version"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("JSON File Version"); |
| if (!root["file_format_version"].isNull()) { |
| PrintTableElement(root["file_format_version"].asString()); |
| } else { |
| PrintTableElement("MISSING!"); |
| } |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Library Path"); |
| if (!root["layer"]["library_path"].isNull()) { |
| PrintTableElement(root["layer"]["library_path"].asString()); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| |
| #ifdef _WIN32 |
| // On Windows, we can query the file version, so do so. |
| char full_layer_path[MAX_STRING_LENGTH]; |
| if (GenerateLibraryPath( |
| layer_json_filename, |
| root["layer"]["library_path"].asString().c_str(), |
| MAX_STRING_LENGTH, full_layer_path) && |
| GetFileVersion(full_layer_path, MAX_STRING_LENGTH, |
| generic_string)) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Layer File Version"); |
| PrintTableElement(generic_string); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| } |
| #endif |
| } else { |
| PrintTableElement("MISSING!"); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| } |
| |
| char count_str[MAX_STRING_LENGTH]; |
| Json::Value dev_exts = root["layer"]["device_extensions"]; |
| ext = 0; |
| if (!dev_exts.isNull() && dev_exts.isArray()) { |
| snprintf(count_str, MAX_STRING_LENGTH - 1, "%d", dev_exts.size()); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Device Extensions"); |
| PrintTableElement(count_str); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| |
| for (Json::ValueIterator dev_ext_it = dev_exts.begin(); |
| dev_ext_it != dev_exts.end(); dev_ext_it++) { |
| Json::Value dev_ext = (*dev_ext_it); |
| Json::Value dev_ext_name = dev_ext["name"]; |
| if (!dev_ext_name.isNull()) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", |
| ext); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(dev_ext_name.asString()); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| } |
| } |
| } |
| Json::Value inst_exts = root["layer"]["instance_extensions"]; |
| ext = 0; |
| if (!inst_exts.isNull() && inst_exts.isArray()) { |
| snprintf(count_str, MAX_STRING_LENGTH - 1, "%d", inst_exts.size()); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Instance Extensions"); |
| PrintTableElement(count_str); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| |
| for (Json::ValueIterator inst_ext_it = inst_exts.begin(); |
| inst_ext_it != inst_exts.end(); inst_ext_it++) { |
| Json::Value inst_ext = (*inst_ext_it); |
| Json::Value inst_ext_name = inst_ext["name"]; |
| if (!inst_ext_name.isNull()) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", |
| ext); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(inst_ext_name.asString()); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| } |
| } |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Layer Section"); |
| PrintTableElement("MISSING!"); |
| cur_col = 3; |
| while (num_cols > cur_col) { |
| PrintTableElement(""); |
| cur_col++; |
| } |
| PrintEndTableRow(); |
| } |
| } |
| |
| // Print out the information about an Implicit layer stored in |
| // it's JSON file. For the most part, it is similar to an |
| // explicit layer, so we re-use that code. However, implicit |
| // layers have a DISABLE environment variable that can be used |
| // to disable the layer by default. Additionally, some implicit |
| // layers have an ENABLE environment variable so that they are |
| // disabled by default, but can be enabled. |
| void PrintImplicitLayerJsonInfo(const char *layer_json_filename, |
| Json::Value root) { |
| bool enabled = true; |
| std::string enable_env_variable = "--NONE--"; |
| bool enable_var_set = false; |
| char enable_env_value[16]; |
| std::string disable_env_variable = "--NONE--"; |
| bool disable_var_set = false; |
| char disable_env_value[16]; |
| |
| PrintExplicitLayerJsonInfo(layer_json_filename, root, 4); |
| |
| Json::Value enable = root["layer"]["enable_environment"]; |
| if (!enable.isNull()) { |
| for (Json::Value::iterator en_iter = enable.begin(); |
| en_iter != enable.end(); en_iter++) { |
| if (en_iter.key().isNull()) { |
| continue; |
| } |
| enable_env_variable = en_iter.key().asString(); |
| // If an enable define exists, set it to disabled by default. |
| enabled = false; |
| #ifdef _WIN32 |
| if (0 != GetEnvironmentVariableA(enable_env_variable.c_str(), |
| enable_env_value, 15)) { |
| #else |
| char *enable_env = getenv(enable_env_variable.c_str()); |
| if (NULL != enable_env) { |
| strncpy(enable_env_value, enable_env, 15); |
| enable_env_value[15] = '\0'; |
| #endif |
| if (atoi(enable_env_value) != 0) { |
| enable_var_set = true; |
| enabled = true; |
| } |
| } |
| break; |
| } |
| } |
| Json::Value disable = root["layer"]["disable_environment"]; |
| if (!disable.isNull()) { |
| for (Json::Value::iterator dis_iter = disable.begin(); |
| dis_iter != disable.end(); dis_iter++) { |
| if (dis_iter.key().isNull()) { |
| continue; |
| } |
| disable_env_variable = dis_iter.key().asString(); |
| #ifdef _WIN32 |
| if (0 != GetEnvironmentVariableA(disable_env_variable.c_str(), |
| disable_env_value, 15)) { |
| #else |
| char *disable_env = getenv(disable_env_variable.c_str()); |
| if (NULL != disable_env) { |
| strncpy(disable_env_value, disable_env, 15); |
| disable_env_value[15] = '\0'; |
| #endif |
| if (atoi(disable_env_value) > 0) { |
| disable_var_set = true; |
| enabled = false; |
| } |
| } |
| break; |
| } |
| } |
| |
| // Print the overall state (ENABLED or DISABLED) so we can |
| // quickly determine if this layer is being used. |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Enabled State"); |
| PrintTableElement(enabled ? "ENABLED" : "DISABLED"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Enable Env Var", ALIGN_RIGHT); |
| PrintTableElement(enable_env_variable); |
| if (enable_var_set) { |
| PrintTableElement(""); |
| } else { |
| PrintTableElement("Not Defined"); |
| } |
| PrintEndTableRow(); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Disable Env Var", ALIGN_RIGHT); |
| PrintTableElement(disable_env_variable); |
| if (disable_var_set) { |
| PrintTableElement(disable_env_value); |
| } else { |
| PrintTableElement("Not Defined"); |
| } |
| PrintEndTableRow(); |
| } |
| |
| // Perform Vulkan commands to find out what extensions are available |
| // to a Vulkan Instance, and attempt to create one. |
| void PrintInstanceInfo(void) { |
| VkApplicationInfo app_info; |
| VkInstanceCreateInfo inst_info; |
| uint32_t ext_count; |
| std::vector<VkExtensionProperties> ext_props; |
| VkResult status; |
| char generic_string[MAX_STRING_LENGTH]; |
| |
| memset(&app_info, 0, sizeof(VkApplicationInfo)); |
| app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; |
| app_info.pNext = NULL; |
| app_info.pApplicationName = "via"; |
| app_info.applicationVersion = 1; |
| app_info.pEngineName = "via"; |
| app_info.engineVersion = 1; |
| app_info.apiVersion = VK_API_VERSION_1_0; |
| |
| memset(&inst_info, 0, sizeof(VkInstanceCreateInfo)); |
| inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; |
| inst_info.pNext = NULL; |
| inst_info.pApplicationInfo = &app_info; |
| inst_info.enabledLayerCount = 0; |
| inst_info.ppEnabledLayerNames = NULL; |
| inst_info.enabledExtensionCount = 0; |
| inst_info.ppEnabledExtensionNames = NULL; |
| |
| PrintBeginTable("Instance", 3); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("vkEnumerateInstanceExtensionProperties"); |
| status = vkEnumerateInstanceExtensionProperties(NULL, &ext_count, NULL); |
| if (status) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "ERROR: Failed to determine num inst extensions - %d", status); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d extensions found", |
| ext_count); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| ext_props.resize(ext_count); |
| status = vkEnumerateInstanceExtensionProperties(NULL, &ext_count, |
| ext_props.data()); |
| if (status) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "ERROR: Failed to enumerate inst extensions - %d", status); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } else { |
| for (uint32_t iii = 0; iii < ext_count; iii++) { |
| PrintBeginTableRow(); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", iii); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(ext_props[iii].extensionName); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "Spec Vers %d", |
| ext_props[iii].specVersion); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement("vkCreateInstance"); |
| status = vkCreateInstance(&inst_info, NULL, &global_items.instance); |
| if (status == VK_ERROR_INCOMPATIBLE_DRIVER) { |
| PrintTableElement("ERROR: Incompatible Driver"); |
| } else if (status == VK_ERROR_OUT_OF_HOST_MEMORY) { |
| PrintTableElement("ERROR: Out of memory"); |
| } else if (status) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "ERROR: Failed to create - %d", status); |
| PrintTableElement(generic_string); |
| } else { |
| PrintTableElement("SUCCESSFUL"); |
| } |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| PrintEndTable(); |
| if (VK_SUCCESS != status) { |
| throw(-1); |
| } |
| } |
| |
| // Print out any information we can find out about physical devices using |
| // the Vulkan commands. There should be one for each Vulkan capable device |
| // on the system. |
| void PrintPhysDevInfo(void) { |
| VkPhysicalDeviceProperties props; |
| std::vector<VkPhysicalDevice> phys_devices; |
| VkResult status; |
| char generic_string[MAX_STRING_LENGTH]; |
| uint32_t gpu_count = 0; |
| uint32_t iii; |
| uint32_t jjj; |
| bool failed = false; |
| |
| PrintBeginTable("Physical Devices", 4); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("vkEnumeratePhysicalDevices"); |
| status = |
| vkEnumeratePhysicalDevices(global_items.instance, &gpu_count, NULL); |
| if (status) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "ERROR: Failed to query - %d", status); |
| PrintTableElement(generic_string); |
| failed = true; |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", gpu_count); |
| PrintTableElement(generic_string); |
| } |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| // If we failed here, the rest will have issues, so, unlike everywhere |
| // else, we'll just return immediately. |
| if (failed) { |
| throw VULKAN_CANT_FIND_DRIVER; |
| } |
| |
| phys_devices.resize(gpu_count); |
| global_items.phys_devices.resize(gpu_count); |
| status = vkEnumeratePhysicalDevices(global_items.instance, &gpu_count, |
| phys_devices.data()); |
| if (VK_SUCCESS != status) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Failed to enumerate physical devices!"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| failed = true; |
| } |
| for (iii = 0; iii < gpu_count; iii++) { |
| global_items.phys_devices[iii].vulkan_phys_dev = phys_devices[iii]; |
| |
| PrintBeginTableRow(); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", iii); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| if (status) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "ERROR: Failed to query - %d", status); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%p", |
| phys_devices[iii]); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| vkGetPhysicalDeviceProperties(phys_devices[iii], &props); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Vendor"); |
| switch (props.vendorID) { |
| case 0x8086: |
| case 0x8087: |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "Intel [0x%04x]", props.vendorID); |
| break; |
| case 0x1002: |
| case 0x1022: |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "AMD [0x%04x]", |
| props.vendorID); |
| break; |
| case 0x10DE: |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "Nvidia [0x%04x]", props.vendorID); |
| break; |
| case 0x1EB5: |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "ARM [0x%04x]", |
| props.vendorID); |
| break; |
| case 0x5143: |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "Qualcomm [0x%04x]", props.vendorID); |
| break; |
| case 0x1099: |
| case 0x10C3: |
| case 0x1249: |
| case 0x4E8: |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "Samsung [0x%04x]", props.vendorID); |
| break; |
| default: |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%04x", |
| props.vendorID); |
| break; |
| } |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Device Name"); |
| PrintTableElement(props.deviceName); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Device ID"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%x", |
| props.deviceID); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Device Type"); |
| switch (props.deviceType) { |
| case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: |
| PrintTableElement("Integrated GPU"); |
| break; |
| case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: |
| PrintTableElement("Discrete GPU"); |
| break; |
| case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: |
| PrintTableElement("Virtual GPU"); |
| break; |
| case VK_PHYSICAL_DEVICE_TYPE_CPU: |
| PrintTableElement("CPU"); |
| break; |
| case VK_PHYSICAL_DEVICE_TYPE_OTHER: |
| PrintTableElement("Other"); |
| break; |
| default: |
| PrintTableElement("INVALID!"); |
| break; |
| } |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Driver Version"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d.%d.%d", |
| VK_VERSION_MAJOR(props.driverVersion), |
| VK_VERSION_MINOR(props.driverVersion), |
| VK_VERSION_PATCH(props.driverVersion)); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("API Version"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d.%d.%d", |
| VK_VERSION_MAJOR(props.apiVersion), |
| VK_VERSION_MINOR(props.apiVersion), |
| VK_VERSION_PATCH(props.apiVersion)); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| uint32_t queue_fam_count; |
| vkGetPhysicalDeviceQueueFamilyProperties(phys_devices[iii], |
| &queue_fam_count, NULL); |
| if (queue_fam_count > 0) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Queue Families"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", |
| queue_fam_count); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| global_items.phys_devices[iii].queue_fam_props.resize( |
| queue_fam_count); |
| vkGetPhysicalDeviceQueueFamilyProperties( |
| phys_devices[iii], &queue_fam_count, |
| global_items.phys_devices[iii].queue_fam_props.data()); |
| for (jjj = 0; jjj < queue_fam_count; jjj++) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", |
| jjj); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement("Queue Count"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", |
| global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .queueCount); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Queue Flags"); |
| generic_string[0] = '\0'; |
| bool prev_set = false; |
| if (global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .queueFlags & |
| VK_QUEUE_GRAPHICS_BIT) { |
| strncat(generic_string, "GRAPHICS", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .queueFlags & |
| VK_QUEUE_COMPUTE_BIT) { |
| if (prev_set) { |
| strncat(generic_string, " | ", |
| MAX_STRING_LENGTH - 1); |
| } |
| strncat(generic_string, "COMPUTE", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .queueFlags & |
| VK_QUEUE_TRANSFER_BIT) { |
| if (prev_set) { |
| strncat(generic_string, " | ", |
| MAX_STRING_LENGTH - 1); |
| } |
| strncat(generic_string, "TRANSFER", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .queueFlags & |
| VK_QUEUE_SPARSE_BINDING_BIT) { |
| if (prev_set) { |
| strncat(generic_string, " | ", |
| MAX_STRING_LENGTH - 1); |
| } |
| strncat(generic_string, "SPARSE_BINDING", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (!prev_set) { |
| strncat(generic_string, "--NONE--", |
| MAX_STRING_LENGTH - 1); |
| } |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Timestamp Valid Bits"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%x", |
| global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .timestampValidBits); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Image Granularity"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Width", ALIGN_RIGHT); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%x", |
| global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .minImageTransferGranularity.width); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Height", ALIGN_RIGHT); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%x", |
| global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .minImageTransferGranularity.height); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Depth", ALIGN_RIGHT); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "0x%x", |
| global_items.phys_devices[iii] |
| .queue_fam_props[jjj] |
| .minImageTransferGranularity.depth); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } else { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("vkGetPhysicalDeviceQueueFamilyProperties"); |
| PrintTableElement("FAILED: Returned 0!"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| } |
| |
| VkPhysicalDeviceMemoryProperties memory_props; |
| vkGetPhysicalDeviceMemoryProperties(phys_devices[iii], |
| &memory_props); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Memory Heaps"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", |
| memory_props.memoryHeapCount); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| for (jjj = 0; jjj < memory_props.memoryHeapCount; jjj++) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", jjj); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement("Property Flags"); |
| generic_string[0] = '\0'; |
| bool prev_set = false; |
| if (memory_props.memoryHeaps[jjj].flags & |
| VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) { |
| strncat(generic_string, "DEVICE_LOCAL", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (!prev_set) { |
| strncat(generic_string, "--NONE--", MAX_STRING_LENGTH - 1); |
| } |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Heap Size"); |
| snprintf( |
| generic_string, MAX_STRING_LENGTH - 1, "%" PRIu64 "", |
| static_cast<uint64_t>(memory_props.memoryHeaps[jjj].size)); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Memory Types"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", |
| memory_props.memoryTypeCount); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| for (jjj = 0; jjj < memory_props.memoryTypeCount; jjj++) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", jjj); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement("Property Flags"); |
| generic_string[0] = '\0'; |
| bool prev_set = false; |
| if (memory_props.memoryTypes[jjj].propertyFlags & |
| VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { |
| strncat(generic_string, "DEVICE_LOCAL", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (memory_props.memoryTypes[jjj].propertyFlags & |
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) { |
| if (prev_set) { |
| strncat(generic_string, " | ", MAX_STRING_LENGTH - 1); |
| } |
| strncat(generic_string, "HOST_VISIBLE", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (memory_props.memoryTypes[jjj].propertyFlags & |
| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) { |
| if (prev_set) { |
| strncat(generic_string, " | ", MAX_STRING_LENGTH - 1); |
| } |
| strncat(generic_string, "HOST_COHERENT", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (memory_props.memoryTypes[jjj].propertyFlags & |
| VK_MEMORY_PROPERTY_HOST_CACHED_BIT) { |
| if (prev_set) { |
| strncat(generic_string, " | ", MAX_STRING_LENGTH - 1); |
| } |
| strncat(generic_string, "HOST_CACHED", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (memory_props.memoryTypes[jjj].propertyFlags & |
| VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) { |
| if (prev_set) { |
| strncat(generic_string, " | ", MAX_STRING_LENGTH - 1); |
| } |
| strncat(generic_string, "LAZILY_ALLOC", |
| MAX_STRING_LENGTH - 1); |
| prev_set = true; |
| } |
| if (!prev_set) { |
| strncat(generic_string, "--NONE--", MAX_STRING_LENGTH - 1); |
| } |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement(""); |
| PrintTableElement("Heap Index"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", |
| memory_props.memoryTypes[jjj].heapIndex); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| |
| uint32_t num_ext_props; |
| std::vector<VkExtensionProperties> ext_props; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| PrintTableElement("Device Extensions"); |
| status = vkEnumerateDeviceExtensionProperties( |
| phys_devices[iii], NULL, &num_ext_props, NULL); |
| if (VK_SUCCESS != status) { |
| PrintTableElement("FAILED querying number of extensions"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| failed = true; |
| } else { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", |
| num_ext_props); |
| PrintTableElement(generic_string); |
| ext_props.resize(num_ext_props); |
| status = vkEnumerateDeviceExtensionProperties( |
| phys_devices[iii], NULL, &num_ext_props, ext_props.data()); |
| if (VK_SUCCESS != status) { |
| PrintTableElement("FAILED querying actual extension info"); |
| PrintEndTableRow(); |
| |
| failed = true; |
| } else { |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| for (jjj = 0; jjj < num_ext_props; jjj++) { |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", |
| jjj); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement(ext_props[jjj].extensionName); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "Spec Vers %d", ext_props[jjj].specVersion); |
| PrintTableElement(generic_string); |
| PrintEndTableRow(); |
| } |
| } |
| } |
| } |
| } |
| |
| PrintEndTable(); |
| |
| if (failed) { |
| throw VULKAN_CANT_FIND_DRIVER; |
| } |
| } |
| |
| // Using the previously determine information, attempt to create a logical |
| // device for each physical device we found. |
| void PrintLogicalDeviceInfo(void) { |
| VkDeviceCreateInfo device_create_info; |
| VkDeviceQueueCreateInfo queue_create_info; |
| VkResult status = VK_SUCCESS; |
| uint32_t dev_count = |
| static_cast<uint32_t>(global_items.phys_devices.size()); |
| char generic_string[MAX_STRING_LENGTH]; |
| bool failed = false; |
| |
| PrintBeginTable("Logical Devices", 3); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("vkCreateDevice"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", dev_count); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| global_items.log_devices.resize(dev_count); |
| for (uint32_t dev = 0; dev < dev_count; dev++) { |
| memset(&device_create_info, 0, sizeof(VkDeviceCreateInfo)); |
| device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; |
| device_create_info.pNext = NULL; |
| device_create_info.queueCreateInfoCount = 0; |
| device_create_info.pQueueCreateInfos = NULL; |
| device_create_info.enabledLayerCount = 0; |
| device_create_info.ppEnabledLayerNames = NULL; |
| device_create_info.enabledExtensionCount = 0; |
| device_create_info.ppEnabledExtensionNames = NULL; |
| device_create_info.queueCreateInfoCount = 1; |
| device_create_info.enabledLayerCount = 0; |
| device_create_info.ppEnabledLayerNames = NULL; |
| device_create_info.enabledExtensionCount = 0; |
| device_create_info.ppEnabledExtensionNames = NULL; |
| |
| memset(&queue_create_info, 0, sizeof(VkDeviceQueueCreateInfo)); |
| float queue_priority = 0; |
| queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; |
| queue_create_info.pNext = NULL; |
| queue_create_info.queueCount = 1; |
| queue_create_info.pQueuePriorities = &queue_priority; |
| |
| for (uint32_t queue = 0; |
| queue < global_items.phys_devices[dev].queue_fam_props.size(); |
| queue++) { |
| if (0 != (global_items.phys_devices[dev] |
| .queue_fam_props[queue] |
| .queueFlags & |
| VK_QUEUE_GRAPHICS_BIT)) { |
| queue_create_info.queueFamilyIndex = queue; |
| break; |
| } |
| } |
| device_create_info.pQueueCreateInfos = &queue_create_info; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", dev); |
| PrintTableElement(generic_string); |
| |
| status = vkCreateDevice(global_items.phys_devices[dev].vulkan_phys_dev, |
| &device_create_info, NULL, |
| &global_items.log_devices[dev]); |
| if (VK_ERROR_INCOMPATIBLE_DRIVER == status) { |
| PrintTableElement("FAILED: Incompatible Driver"); |
| failed = true; |
| } else if (VK_ERROR_OUT_OF_HOST_MEMORY == status) { |
| PrintTableElement("FAILED: Out of Host Memory"); |
| failed = true; |
| } else if (VK_SUCCESS != status) { |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, |
| "FAILED : VkResult code = 0x%x", status); |
| PrintTableElement(generic_string); |
| failed = true; |
| } else { |
| PrintTableElement("SUCCESSFUL"); |
| } |
| |
| PrintEndTableRow(); |
| } |
| |
| PrintEndTable(); |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Clean up all the Vulkan items we previously created and print |
| // out if there are any problems. |
| void PrintCleanupInfo(void) { |
| char generic_string[MAX_STRING_LENGTH]; |
| uint32_t dev_count = |
| static_cast<uint32_t>(global_items.phys_devices.size()); |
| |
| PrintBeginTable("Cleanup", 3); |
| |
| PrintBeginTableRow(); |
| PrintTableElement("vkDestroyDevice"); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "%d", dev_count); |
| PrintTableElement(generic_string); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| for (uint32_t dev = 0; dev < dev_count; dev++) { |
| vkDestroyDevice(global_items.log_devices[dev], NULL); |
| PrintBeginTableRow(); |
| PrintTableElement(""); |
| snprintf(generic_string, MAX_STRING_LENGTH - 1, "[%d]", dev); |
| PrintTableElement(generic_string, ALIGN_RIGHT); |
| PrintTableElement("SUCCESSFUL"); |
| PrintEndTableRow(); |
| } |
| |
| PrintBeginTableRow(); |
| PrintTableElement("vkDestroyInstance"); |
| vkDestroyInstance(global_items.instance, NULL); |
| PrintTableElement("SUCCESSFUL"); |
| PrintTableElement(""); |
| PrintEndTableRow(); |
| |
| PrintEndTable(); |
| } |
| |
| // Run any external tests we can find, and print the results of those |
| // tests. |
| void PrintTestResults(void) { |
| bool failed = false; |
| |
| BeginSection("External Tests"); |
| if (global_items.sdk_found) { |
| std::string cube_exe; |
| std::string full_cmd; |
| std::string path = global_items.sdk_path; |
| |
| #ifdef _WIN32 |
| cube_exe = "cube.exe"; |
| |
| #if _WIN64 |
| path += "\\Bin"; |
| #else |
| path += "\\Bin32"; |
| #endif |
| #else // gcc |
| cube_exe = "./cube"; |
| path += "/../examples/build"; |
| #endif |
| full_cmd = cube_exe; |
| full_cmd += " --c 100"; |
| |
| PrintBeginTable("Cube", 2); |
| |
| PrintBeginTableRow(); |
| PrintTableElement(full_cmd); |
| int test_result = RunTestInDirectory(path, cube_exe, full_cmd); |
| if (test_result == 0) { |
| PrintTableElement("SUCCESSFUL"); |
| } else if (test_result == 1) { |
| PrintTableElement("Not Found"); |
| } else { |
| PrintTableElement("FAILED!"); |
| failed = true; |
| } |
| PrintEndTableRow(); |
| |
| full_cmd += " --validate"; |
| |
| PrintBeginTableRow(); |
| PrintTableElement(full_cmd); |
| test_result = RunTestInDirectory(path, cube_exe, full_cmd); |
| if (test_result == 0) { |
| PrintTableElement("SUCCESSFUL"); |
| } else if (test_result == 1) { |
| PrintTableElement("Not Found"); |
| } else { |
| PrintTableElement("FAILED!"); |
| failed = true; |
| } |
| PrintEndTableRow(); |
| |
| PrintEndTable(); |
| } else { |
| PrintStandardText("No SDK found by VIA, skipping test section"); |
| } |
| EndSection(); |
| |
| if (failed) { |
| throw(-1); |
| } |
| } |
| |
| // Print information on any Vulkan commands we can (or can't) execute. |
| void PrintVulkanInfo(void) { |
| BeginSection("Vulkan API Calls"); |
| |
| PrintInstanceInfo(); |
| PrintPhysDevInfo(); |
| PrintLogicalDeviceInfo(); |
| PrintCleanupInfo(); |
| |
| EndSection(); |
| } |
