| /* | |
| * XML DRI client-side driver configuration | |
| * Copyright (C) 2003 Felix Kuehling | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a | |
| * copy of this software and associated documentation files (the "Software"), | |
| * to deal in the Software without restriction, including without limitation | |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| * and/or sell copies of the Software, and to permit persons to whom the | |
| * Software is furnished to do so, subject to the following conditions: | |
| * | |
| * The above copyright notice and this permission notice shall be included | |
| * in all copies or substantial portions of the Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| * FELIX KUEHLING, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, | |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE | |
| * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
| * | |
| */ | |
| /** | |
| * \file xmlconfig.c | |
| * \brief Driver-independent client-side part of the XML configuration | |
| * \author Felix Kuehling | |
| */ | |
| #include "xmlconfig.h" | |
| #include <ctype.h> | |
| #include <limits.h> | |
| #include <stdarg.h> | |
| #include <stdbool.h> | |
| #include <stdint.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <assert.h> | |
| #if WITH_XMLCONFIG | |
| #include <expat.h> | |
| #include <unistd.h> | |
| #include <errno.h> | |
| #include <dirent.h> | |
| #include <sys/stat.h> | |
| #endif | |
| #ifdef NO_REGEX | |
| typedef int regex_t; | |
| #define REG_EXTENDED 0 | |
| #define REG_NOSUB 0 | |
| #define REG_NOMATCH 1 | |
| static inline int regcomp(regex_t *r, const char *s, int f) { return 0; } | |
| static inline int regexec(regex_t *r, const char *s, int n, void *p, int f) { return REG_NOMATCH; } | |
| static inline void regfree(regex_t* r) {} | |
| #else | |
| #include <regex.h> | |
| #endif | |
| #include <fcntl.h> | |
| #include <math.h> | |
| #include "strndup.h" | |
| #include "log.h" | |
| #include "u_process.h" | |
| #include "os_file.h" | |
| #include "os_misc.h" | |
| #include "detect_os.h" | |
| #if DETECT_OS_LINUX | |
| #include <strings.h> | |
| #endif | |
| /* For systems like Hurd */ | |
| #ifndef PATH_MAX | |
| #define PATH_MAX 4096 | |
| #endif | |
| static bool | |
| be_verbose(void) | |
| { | |
| const char *s = os_get_option("MESA_DEBUG"); | |
| if (!s) | |
| return true; | |
| return strstr(s, "silent") == NULL; | |
| } | |
| /** \brief Locale-independent 64-bit integer parser. | |
| * | |
| * Works similar to strtol. Leading space is NOT skipped. If the sign | |
| * argument is non-null, the input number may have an optional sign. | |
| * Radix is specified by base. If base is 0 then decimal is assumed | |
| * unless the input number is prefixed by 0x or 0X for hexadecimal or | |
| * 0 for octal. After returning tail points to the first character | |
| * that is not part of the integer number. If no number was found then | |
| * tail points to the start of the input string. Out-of-range values | |
| * are truncated. */ | |
| static uint64_t | |
| strToInteger(const char *string, const char **tail, int *sign, int base) | |
| { | |
| int radix = base == 0 ? 10 : base; | |
| uint64_t result = 0; | |
| bool numberFound = false; | |
| const char *start = string; | |
| assert(radix >= 2 && radix <= 36); | |
| if (sign) { | |
| *sign = 1; | |
| if (*string == '-') { | |
| *sign = -1; | |
| string++; | |
| } else if (*string == '+') | |
| string++; | |
| } | |
| if (base == 0 && *string == '0') { | |
| numberFound = true; | |
| if (*(string+1) == 'x' || *(string+1) == 'X') { | |
| radix = 16; | |
| string += 2; | |
| } else { | |
| radix = 8; | |
| string++; | |
| } | |
| } | |
| do { | |
| int digit = -1; | |
| if (radix <= 10) { | |
| if (*string >= '0' && *string < '0' + radix) | |
| digit = *string - '0'; | |
| } else { | |
| if (*string >= '0' && *string <= '9') | |
| digit = *string - '0'; | |
| else if (*string >= 'a' && *string < 'a' + radix - 10) | |
| digit = *string - 'a' + 10; | |
| else if (*string >= 'A' && *string < 'A' + radix - 10) | |
| digit = *string - 'A' + 10; | |
| } | |
| if (digit != -1) { | |
| numberFound = true; | |
| result = radix*result + digit; | |
| string++; | |
| } else | |
| break; | |
| } while (true); | |
| *tail = numberFound ? string : start; | |
| return result; | |
| } | |
| /** \brief Locale-independent integer parser. | |
| * | |
| * Follows the semantics of strToInteger, allowing a sign character. */ | |
| static int | |
| strToI(const char *string, const char **tail, int base) | |
| { | |
| int sign; | |
| int result = strToInteger(string, tail, &sign, base); | |
| return sign * result; | |
| } | |
| /** \brief Locale-independent 64-bit unsigned integer parser. | |
| * | |
| * Follows the semantics of strToInteger, without allowing a sign | |
| * character. */ | |
| static uint64_t | |
| strToU64(const char *string, const char **tail, int base) | |
| { | |
| return strToInteger(string, tail, NULL, base); | |
| } | |
| /** \brief Locale-independent floating-point parser. | |
| * | |
| * Works similar to strtod. Leading space is NOT skipped. The input | |
| * number may have an optional sign. '.' is interpreted as decimal | |
| * point and may occur at most once. Optionally the number may end in | |
| * [eE]<exponent>, where <exponent> is an integer as recognized by | |
| * strToI. In that case the result is number * 10^exponent. After | |
| * returning tail points to the first character that is not part of | |
| * the floating point number. If no number was found then tail points | |
| * to the start of the input string. | |
| * | |
| * Uses two passes for maximum accuracy. */ | |
| static float | |
| strToF(const char *string, const char **tail) | |
| { | |
| int nDigits = 0, pointPos, exponent; | |
| float sign = 1.0f, result = 0.0f, scale; | |
| const char *start = string, *numStart; | |
| /* sign */ | |
| if (*string == '-') { | |
| sign = -1.0f; | |
| string++; | |
| } else if (*string == '+') | |
| string++; | |
| /* first pass: determine position of decimal point, number of | |
| * digits, exponent and the end of the number. */ | |
| numStart = string; | |
| while (*string >= '0' && *string <= '9') { | |
| string++; | |
| nDigits++; | |
| } | |
| pointPos = nDigits; | |
| if (*string == '.') { | |
| string++; | |
| while (*string >= '0' && *string <= '9') { | |
| string++; | |
| nDigits++; | |
| } | |
| } | |
| if (nDigits == 0) { | |
| /* no digits, no number */ | |
| *tail = start; | |
| return 0.0f; | |
| } | |
| *tail = string; | |
| if (*string == 'e' || *string == 'E') { | |
| const char *expTail; | |
| exponent = strToI(string+1, &expTail, 10); | |
| if (expTail == string+1) | |
| exponent = 0; | |
| else | |
| *tail = expTail; | |
| } else | |
| exponent = 0; | |
| string = numStart; | |
| /* scale of the first digit */ | |
| scale = sign * (float)pow(10.0, (double)(pointPos-1 + exponent)); | |
| /* second pass: parse digits */ | |
| do { | |
| if (*string != '.') { | |
| assert(*string >= '0' && *string <= '9'); | |
| result += scale * (float)(*string - '0'); | |
| scale *= 0.1f; | |
| nDigits--; | |
| } | |
| string++; | |
| } while (nDigits > 0); | |
| return result; | |
| } | |
| /** \brief Parse a value of a given type. */ | |
| static unsigned char | |
| parseValue(driOptionValue *v, driOptionType type, const char *string) | |
| { | |
| const char *tail = NULL; | |
| /* skip leading white-space */ | |
| string += strspn(string, " \f\n\r\t\v"); | |
| switch (type) { | |
| case DRI_BOOL: | |
| if (!strcmp(string, "false")) { | |
| v->_bool = false; | |
| tail = string + 5; | |
| } else if (!strcmp(string, "true")) { | |
| v->_bool = true; | |
| tail = string + 4; | |
| } | |
| else | |
| return false; | |
| break; | |
| case DRI_ENUM: /* enum is just a special integer */ | |
| case DRI_INT: | |
| v->_int = strToI(string, &tail, 0); | |
| break; | |
| case DRI_UINT64: | |
| v->_uint64 = strToU64(string, &tail, 0); | |
| break; | |
| case DRI_FLOAT: | |
| v->_float = strToF(string, &tail); | |
| break; | |
| case DRI_STRING: | |
| free(v->_string); | |
| v->_string = strndup(string, STRING_CONF_MAXLEN); | |
| return true; | |
| case DRI_SECTION: | |
| UNREACHABLE("shouldn't be parsing values in section declarations"); | |
| } | |
| if (tail == string) | |
| return false; /* empty string (or containing only white-space) */ | |
| /* skip trailing white space */ | |
| if (*tail) | |
| tail += strspn(tail, " \f\n\r\t\v"); | |
| if (*tail) | |
| return false; /* something left over that is not part of value */ | |
| return true; | |
| } | |
| /** \brief Find an option in an option cache with the name as key */ | |
| static uint32_t | |
| findOption(const driOptionCache *cache, const char *name) | |
| { | |
| uint32_t len = strlen(name); | |
| uint32_t size = 1 << cache->tableSize, mask = size - 1; | |
| uint32_t hash = 0; | |
| uint32_t i, shift; | |
| /* compute a hash from the variable length name */ | |
| for (i = 0, shift = 0; i < len; ++i, shift = (shift+8) & 31) | |
| hash += (uint32_t)name[i] << shift; | |
| hash *= hash; | |
| hash = (hash >> (16-cache->tableSize/2)) & mask; | |
| /* this is just the starting point of the linear search for the option */ | |
| for (i = 0; i < size; ++i, hash = (hash+1) & mask) { | |
| /* if we hit an empty entry then the option is not defined (yet) */ | |
| if (cache->info[hash].name == NULL) | |
| break; | |
| else if (!strcmp(name, cache->info[hash].name)) | |
| break; | |
| } | |
| /* this assertion fails if the hash table is full */ | |
| assert (i < size); | |
| return hash; | |
| } | |
| /** \brief Like strdup with error checking. */ | |
| #define XSTRDUP(dest,source) do { \ | |
| if (!(dest = strdup(source))) { \ | |
| fprintf(stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__); \ | |
| abort(); \ | |
| } \ | |
| } while (0) | |
| /** \brief Check if a value is in info->range. */ | |
| UNUSED static bool | |
| checkValue(const driOptionValue *v, const driOptionInfo *info) | |
| { | |
| switch (info->type) { | |
| case DRI_ENUM: /* enum is just a special integer */ | |
| case DRI_INT: | |
| return (info->range.start._int == info->range.end._int || | |
| (v->_int >= info->range.start._int && | |
| v->_int <= info->range.end._int)); | |
| case DRI_UINT64: | |
| return (info->range.start._uint64 == info->range.end._uint64 || | |
| (v->_uint64 >= info->range.start._uint64 && | |
| v->_uint64 <= info->range.end._uint64)); | |
| case DRI_FLOAT: | |
| return (info->range.start._float == info->range.end._float || | |
| (v->_float >= info->range.start._float && | |
| v->_float <= info->range.end._float)); | |
| default: | |
| return true; | |
| } | |
| } | |
| void | |
| driParseOptionInfo(driOptionCache *info, | |
| const driOptionDescription *configOptions, | |
| unsigned numOptions) | |
| { | |
| /* Make the hash table big enough to fit more than the maximum number of | |
| * config options we've ever seen in a driver. | |
| */ | |
| info->tableSize = 7; | |
| info->info = calloc((size_t)1 << info->tableSize, sizeof(driOptionInfo)); | |
| info->values = calloc((size_t)1 << info->tableSize, sizeof(driOptionValue)); | |
| if (info->info == NULL || info->values == NULL) { | |
| fprintf(stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__); | |
| abort(); | |
| } | |
| UNUSED bool in_section = false; | |
| for (int o = 0; o < numOptions; o++) { | |
| const driOptionDescription *opt = &configOptions[o]; | |
| if (opt->info.type == DRI_SECTION) { | |
| in_section = true; | |
| continue; | |
| } | |
| /* for driconf xml generation, options must always be preceded by a | |
| * DRI_CONF_SECTION | |
| */ | |
| assert(in_section); | |
| const char *name = opt->info.name; | |
| int i = findOption(info, name); | |
| driOptionInfo *optinfo = &info->info[i]; | |
| driOptionValue *optval = &info->values[i]; | |
| if (optinfo->name) { | |
| /* Duplicate options override the value, but the type must match. */ | |
| assert(optinfo->type == opt->info.type); | |
| } else { | |
| XSTRDUP(optinfo->name, name); | |
| } | |
| optinfo->type = opt->info.type; | |
| optinfo->range = opt->info.range; | |
| switch (opt->info.type) { | |
| case DRI_BOOL: | |
| optval->_bool = opt->value._bool; | |
| break; | |
| case DRI_INT: | |
| case DRI_ENUM: | |
| optval->_int = opt->value._int; | |
| break; | |
| case DRI_UINT64: | |
| optval->_uint64 = opt->value._uint64; | |
| break; | |
| case DRI_FLOAT: | |
| optval->_float = opt->value._float; | |
| break; | |
| case DRI_STRING: | |
| XSTRDUP(optval->_string, opt->value._string); | |
| break; | |
| case DRI_SECTION: | |
| UNREACHABLE("handled above"); | |
| } | |
| /* Built-in default values should always be valid. */ | |
| assert(checkValue(optval, optinfo)); | |
| const char *envVal = os_get_option(name); | |
| if (envVal != NULL) { | |
| driOptionValue v; | |
| /* make sure the value is initialized to something sensible */ | |
| v._string = NULL; | |
| if (parseValue(&v, opt->info.type, envVal) && | |
| checkValue(&v, optinfo)) { | |
| /* don't use XML_WARNING, we want the user to see this! */ | |
| if (be_verbose()) { | |
| fprintf(stderr, | |
| "ATTENTION: default value of option %s overridden by environment.\n", | |
| name); | |
| } | |
| *optval = v; | |
| } else { | |
| fprintf(stderr, "illegal environment value for %s: \"%s\". Ignoring.\n", | |
| name, envVal); | |
| } | |
| } | |
| } | |
| } | |
| char * | |
| driGetOptionsXml(const driOptionDescription *configOptions, unsigned numOptions) | |
| { | |
| char *str = ralloc_strdup(NULL, | |
| "<?xml version=\"1.0\" standalone=\"yes\"?>\n" \ | |
| "<!DOCTYPE driinfo [\n" \ | |
| " <!ELEMENT driinfo (section*)>\n" \ | |
| " <!ELEMENT section (description+, option+)>\n" \ | |
| " <!ELEMENT description (enum*)>\n" \ | |
| " <!ATTLIST description lang CDATA #FIXED \"en\"\n" \ | |
| " text CDATA #REQUIRED>\n" \ | |
| " <!ELEMENT option (description+)>\n" \ | |
| " <!ATTLIST option name CDATA #REQUIRED\n" \ | |
| " type (bool|enum|int|float) #REQUIRED\n" \ | |
| " default CDATA #REQUIRED\n" \ | |
| " valid CDATA #IMPLIED>\n" \ | |
| " <!ELEMENT enum EMPTY>\n" \ | |
| " <!ATTLIST enum value CDATA #REQUIRED\n" \ | |
| " text CDATA #REQUIRED>\n" \ | |
| "]>" \ | |
| "<driinfo>\n"); | |
| bool in_section = false; | |
| for (int o = 0; o < numOptions; o++) { | |
| const driOptionDescription *opt = &configOptions[o]; | |
| const char *name = opt->info.name; | |
| const char *types[] = { | |
| [DRI_BOOL] = "bool", | |
| [DRI_INT] = "int", | |
| [DRI_UINT64] = "uint64", | |
| [DRI_FLOAT] = "float", | |
| [DRI_ENUM] = "enum", | |
| [DRI_STRING] = "string", | |
| }; | |
| if (opt->info.type == DRI_SECTION) { | |
| if (in_section) | |
| ralloc_asprintf_append(&str, " </section>\n"); | |
| ralloc_asprintf_append(&str, | |
| " <section>\n" | |
| " <description lang=\"en\" text=\"%s\"/>\n", | |
| opt->desc); | |
| in_section = true; | |
| continue; | |
| } | |
| ralloc_asprintf_append(&str, | |
| " <option name=\"%s\" type=\"%s\" default=\"", | |
| name, | |
| types[opt->info.type]); | |
| switch (opt->info.type) { | |
| case DRI_BOOL: | |
| ralloc_asprintf_append(&str, opt->value._bool ? "true" : "false"); | |
| break; | |
| case DRI_INT: | |
| case DRI_ENUM: | |
| ralloc_asprintf_append(&str, "%d", opt->value._int); | |
| break; | |
| case DRI_UINT64: | |
| ralloc_asprintf_append(&str, "%" PRIu64, opt->value._uint64); | |
| break; | |
| case DRI_FLOAT: | |
| ralloc_asprintf_append(&str, "%f", opt->value._float); | |
| break; | |
| case DRI_STRING: | |
| ralloc_asprintf_append(&str, "%s", opt->value._string); | |
| break; | |
| case DRI_SECTION: | |
| UNREACHABLE("handled above"); | |
| break; | |
| } | |
| ralloc_asprintf_append(&str, "\""); | |
| switch (opt->info.type) { | |
| case DRI_INT: | |
| case DRI_ENUM: | |
| if (opt->info.range.start._int < opt->info.range.end._int) { | |
| ralloc_asprintf_append(&str, " valid=\"%d:%d\"", | |
| opt->info.range.start._int, | |
| opt->info.range.end._int); | |
| } | |
| break; | |
| case DRI_UINT64: | |
| if (opt->info.range.start._uint64 < opt->info.range.end._uint64) { | |
| ralloc_asprintf_append(&str, " valid=\"%" PRIu64 ":%" PRIu64 "\"", | |
| opt->info.range.start._uint64, | |
| opt->info.range.end._uint64); | |
| } | |
| break; | |
| case DRI_FLOAT: | |
| if (opt->info.range.start._float < opt->info.range.end._float) { | |
| ralloc_asprintf_append(&str, " valid=\"%f:%f\"", | |
| opt->info.range.start._float, | |
| opt->info.range.end._float); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| ralloc_asprintf_append(&str, ">\n"); /* end of <option> */ | |
| ralloc_asprintf_append(&str, " <description lang=\"en\" text=\"%s\"%s>\n", | |
| opt->desc, opt->info.type != DRI_ENUM ? "/" : ""); | |
| if (opt->info.type == DRI_ENUM) { | |
| for (int i = 0; i < ARRAY_SIZE(opt->enums) && opt->enums[i].desc; i++) { | |
| ralloc_asprintf_append(&str, " <enum value=\"%d\" text=\"%s\"/>\n", | |
| opt->enums[i].value, opt->enums[i].desc); | |
| } | |
| ralloc_asprintf_append(&str, " </description>\n"); | |
| } | |
| ralloc_asprintf_append(&str, " </option>\n"); | |
| } | |
| assert(in_section); | |
| ralloc_asprintf_append(&str, " </section>\n"); | |
| ralloc_asprintf_append(&str, "</driinfo>\n"); | |
| char *output = strdup(str); | |
| ralloc_free(str); | |
| return output; | |
| } | |
| /** | |
| * Print message to \c stderr if the \c LIBGL_DEBUG environment variable | |
| * is set. | |
| * | |
| * Is called from the drivers. | |
| * | |
| * \param f \c printf like format string. | |
| */ | |
| static void | |
| __driUtilMessage(const char *f, ...) | |
| { | |
| va_list args; | |
| const char *libgl_debug; | |
| libgl_debug=os_get_option("LIBGL_DEBUG"); | |
| if (libgl_debug && !strstr(libgl_debug, "quiet")) { | |
| fprintf(stderr, "libGL: "); | |
| va_start(args, f); | |
| vfprintf(stderr, f, args); | |
| va_end(args); | |
| fprintf(stderr, "\n"); | |
| } | |
| } | |
| /* We don't have real line/column # info in static-config case: */ | |
| #if !WITH_XML_CONFIG | |
| # define XML_GetCurrentLineNumber(p) -1 | |
| # define XML_GetCurrentColumnNumber(p) -1 | |
| #endif | |
| /** \brief Output a warning message. */ | |
| #define XML_WARNING1(msg) do { \ | |
| __driUtilMessage("Warning in %s line %d, column %d: "msg, data->name, \ | |
| (int) XML_GetCurrentLineNumber(data->parser), \ | |
| (int) XML_GetCurrentColumnNumber(data->parser)); \ | |
| } while (0) | |
| #define XML_WARNING(msg, ...) do { \ | |
| __driUtilMessage("Warning in %s line %d, column %d: "msg, data->name, \ | |
| (int) XML_GetCurrentLineNumber(data->parser), \ | |
| (int) XML_GetCurrentColumnNumber(data->parser), \ | |
| ##__VA_ARGS__); \ | |
| } while (0) | |
| /** \brief Output an error message. */ | |
| #define XML_ERROR1(msg) do { \ | |
| __driUtilMessage("Error in %s line %d, column %d: "msg, data->name, \ | |
| (int) XML_GetCurrentLineNumber(data->parser), \ | |
| (int) XML_GetCurrentColumnNumber(data->parser)); \ | |
| } while (0) | |
| #define XML_ERROR(msg, ...) do { \ | |
| __driUtilMessage("Error in %s line %d, column %d: "msg, data->name, \ | |
| (int) XML_GetCurrentLineNumber(data->parser), \ | |
| (int) XML_GetCurrentColumnNumber(data->parser), \ | |
| ##__VA_ARGS__); \ | |
| } while (0) | |
| /** \brief Parser context for configuration files. */ | |
| struct OptConfData { | |
| const char *name; | |
| #if WITH_XMLCONFIG | |
| XML_Parser parser; | |
| #endif | |
| driOptionCache *cache; | |
| int screenNum; | |
| const char *driverName, *execName; | |
| const char *kernelDriverName; | |
| const char *deviceName; | |
| uint32_t deviceVersion; | |
| const char *engineName; | |
| const char *applicationName; | |
| union { | |
| blake3_hash blake3; | |
| uint64_t u64; | |
| } shaderHash; | |
| uint32_t shaderHashSize; | |
| uint32_t engineVersion; | |
| uint32_t applicationVersion; | |
| uint32_t ignoringDevice; | |
| uint32_t ignoringApp; | |
| uint32_t inDriConf; | |
| uint32_t inDevice; | |
| uint32_t inApp; | |
| uint32_t inShader; | |
| uint32_t inOption; | |
| driShaderOptionCallback shaderOptionCallback; | |
| void *shaderOptionCallbackData; | |
| }; | |
| /** \brief Parse a list of ranges of type info->type. */ | |
| static unsigned char | |
| parseRange(driOptionInfo *info, const char *string) | |
| { | |
| char *cp; | |
| XSTRDUP(cp, string); | |
| char *sep; | |
| sep = strchr(cp, ':'); | |
| if (!sep) { | |
| free(cp); | |
| return false; | |
| } | |
| *sep = '\0'; | |
| if (!parseValue(&info->range.start, info->type, cp) || | |
| !parseValue(&info->range.end, info->type, sep+1)) { | |
| free(cp); | |
| return false; | |
| } | |
| if (info->type == DRI_INT && | |
| info->range.start._int >= info->range.end._int) { | |
| free(cp); | |
| return false; | |
| } | |
| if (info->type == DRI_UINT64 && | |
| info->range.start._uint64 >= info->range.end._uint64) { | |
| free(cp); | |
| return false; | |
| } | |
| if (info->type == DRI_FLOAT && | |
| info->range.start._float >= info->range.end._float) { | |
| free(cp); | |
| return false; | |
| } | |
| free(cp); | |
| return true; | |
| } | |
| /** \brief Parse attributes of a device element. */ | |
| static void | |
| parseDeviceAttr(struct OptConfData *data, const char **attr) | |
| { | |
| uint32_t i; | |
| const char *driver = NULL, *screen = NULL, *kernel = NULL, *device = NULL; | |
| const char *device_version_regexp = NULL; | |
| for (i = 0; attr[i]; i += 2) { | |
| if (!strcmp(attr[i], "driver")) driver = attr[i+1]; | |
| else if (!strcmp(attr[i], "screen")) screen = attr[i+1]; | |
| else if (!strcmp(attr[i], "kernel_driver")) kernel = attr[i+1]; | |
| else if (!strcmp(attr[i], "device")) device = attr[i+1]; | |
| else if (!strcmp(attr[i], "device_version_regexp")) device_version_regexp = attr[i+1]; | |
| else XML_WARNING("unknown device attribute: %s.", attr[i]); | |
| } | |
| if (driver && strcmp(driver, data->driverName)) | |
| data->ignoringDevice = data->inDevice; | |
| else if (kernel && (!data->kernelDriverName || | |
| strcmp(kernel, data->kernelDriverName))) | |
| data->ignoringDevice = data->inDevice; | |
| else if (device && (!data->deviceName || | |
| strcmp(device, data->deviceName))) | |
| data->ignoringDevice = data->inDevice; | |
| else if (device_version_regexp) { | |
| /* device_version_regexp: Extended regex pattern matching on device version. | |
| * Uses POSIX extended regular expressions (ERE). | |
| * | |
| * Examples: | |
| * "^(40|50|60)$" - Match exact versions 40, 50, or 60 | |
| * "^[4-6][0-9]$" - Match versions 40-69 | |
| * "^12[0-9]" - Match versions starting with 12 (120-129) | |
| */ | |
| if (!data->deviceVersion) { | |
| data->ignoringDevice = data->inDevice; | |
| } else { | |
| regex_t re; | |
| if (regcomp(&re, device_version_regexp, REG_EXTENDED|REG_NOSUB) == 0) { | |
| char device_version_str[32]; | |
| snprintf(device_version_str, sizeof(device_version_str), "%u", data->deviceVersion); | |
| if (regexec(&re, device_version_str, 0, NULL, 0) == REG_NOMATCH) | |
| data->ignoringDevice = data->inDevice; | |
| regfree(&re); | |
| } else | |
| XML_WARNING("Invalid device_version_regexp=\"%s\".", device_version_regexp); | |
| } | |
| } else if (screen) { | |
| driOptionValue screenNum; | |
| if (!parseValue(&screenNum, DRI_INT, screen)) | |
| XML_WARNING("illegal screen number: %s.", screen); | |
| else if (screenNum._int != data->screenNum) | |
| data->ignoringDevice = data->inDevice; | |
| } | |
| } | |
| /** | |
| * Read the executable that execName refers to, for hashing. | |
| * | |
| * This is usually the process executable, but not under Wine: there | |
| * /proc/self/exe is the wine loader, while execName comes from argv[0], which | |
| * Wine sets to the PE executable (e.g. "C:\\path\\game.exe"). The PE file is | |
| * mapped into the process, so find it among the mapped files instead. Falls | |
| * back to the process executable when there is no better match. | |
| */ | |
| static char * | |
| readAppExecutable(struct OptConfData *data, size_t *len) | |
| { | |
| char path[PATH_MAX]; | |
| const char *name; | |
| if (util_get_process_exec_path(path, ARRAY_SIZE(path)) > 0) { | |
| name = strrchr(path, '/'); | |
| name = name ? name + 1 : path; | |
| if (!strcmp(name, data->execName)) | |
| return os_read_file(path, len); | |
| } else { | |
| path[0] = 0; | |
| } | |
| #if DETECT_OS_LINUX | |
| /* Not the process executable, so look for a mapped file called execName. | |
| * Windows file names are case-insensitive, and argv[0] doesn't have to | |
| * match the case on disk. | |
| */ | |
| FILE *maps = fopen("/proc/self/maps", "r"); | |
| if (maps) { | |
| char *content = NULL; | |
| char *line = NULL; | |
| size_t line_size = 0; | |
| while (getline(&line, &line_size, maps) > 0) { | |
| /* The only field of a maps line that can contain '/' is the path. */ | |
| char *mapped = strchr(line, '/'); | |
| if (!mapped) | |
| continue; | |
| char *end = strchr(mapped, '\n'); | |
| if (end) | |
| *end = 0; | |
| name = strrchr(mapped, '/') + 1; | |
| if (!strcasecmp(name, data->execName)) { | |
| content = os_read_file(mapped, len); | |
| break; | |
| } | |
| } | |
| free(line); | |
| fclose(maps); | |
| if (content) | |
| return content; | |
| } | |
| #endif | |
| return path[0] ? os_read_file(path, len) : NULL; | |
| } | |
| /** \brief Parse attributes of an application element. */ | |
| static void | |
| parseAppAttr(struct OptConfData *data, const char **attr) | |
| { | |
| uint32_t i; | |
| const char *exec = NULL; | |
| const char *blake3 = NULL; | |
| const char *exec_regexp = NULL; | |
| const char *application_name_match = NULL; | |
| const char *application_versions = NULL; | |
| driOptionInfo version_range = { | |
| .type = DRI_INT, | |
| }; | |
| for (i = 0; attr[i]; i += 2) { | |
| if (!strcmp(attr[i], "name")) /* not needed here */; | |
| else if (!strcmp(attr[i], "executable")) exec = attr[i+1]; | |
| else if (!strcmp(attr[i], "executable_regexp")) exec_regexp = attr[i+1]; | |
| else if (!strcmp(attr[i], "blake3")) blake3 = attr[i+1]; | |
| else if (!strcmp(attr[i], "application_name_match")) | |
| application_name_match = attr[i+1]; | |
| else if (!strcmp(attr[i], "application_versions")) | |
| application_versions = attr[i+1]; | |
| else XML_WARNING("unknown application attribute: %s.", attr[i]); | |
| } | |
| if (exec && strcmp(exec, data->execName)) { | |
| data->ignoringApp = data->inApp; | |
| } else if (exec_regexp) { | |
| regex_t re; | |
| if (regcomp(&re, exec_regexp, REG_EXTENDED|REG_NOSUB) == 0) { | |
| if (regexec(&re, data->execName, 0, NULL, 0) == REG_NOMATCH) | |
| data->ignoringApp = data->inApp; | |
| regfree(&re); | |
| } else | |
| XML_WARNING("Invalid executable_regexp=\"%s\".", exec_regexp); | |
| } else if (blake3) { | |
| /* BLAKE3_HEX_LEN includes terminating null byte */ | |
| if (strlen(blake3) != (BLAKE3_HEX_LEN - 1)) { | |
| XML_WARNING("Incorrect blake3 application attribute"); | |
| data->ignoringApp = data->inApp; | |
| } else { | |
| size_t len; | |
| char* content; | |
| if ((content = readAppExecutable(data, &len))) { | |
| uint8_t blake3x[BLAKE3_KEY_LEN]; | |
| char blake3s[BLAKE3_HEX_LEN]; | |
| _mesa_blake3_compute(content, len, blake3x); | |
| _mesa_blake3_format((char*) blake3s, blake3x); | |
| free(content); | |
| if (strcmp(blake3, blake3s)) { | |
| data->ignoringApp = data->inApp; | |
| } | |
| } else { | |
| data->ignoringApp = data->inApp; | |
| } | |
| } | |
| } else if (application_name_match) { | |
| regex_t re; | |
| if (regcomp(&re, application_name_match, REG_EXTENDED|REG_NOSUB) == 0) { | |
| if (regexec(&re, data->applicationName, 0, NULL, 0) == REG_NOMATCH) | |
| data->ignoringApp = data->inApp; | |
| regfree(&re); | |
| } else | |
| XML_WARNING("Invalid application_name_match=\"%s\".", application_name_match); | |
| } | |
| if (application_versions) { | |
| driOptionValue v = { ._int = data->applicationVersion }; | |
| if (parseRange(&version_range, application_versions)) { | |
| if (!checkValue(&v, &version_range)) | |
| data->ignoringApp = data->inApp; | |
| } else { | |
| XML_WARNING("Failed to parse application_versions range=\"%s\".", | |
| application_versions); | |
| } | |
| } | |
| } | |
| /** \brief Parse attributes of an application element. */ | |
| static void | |
| parseEngineAttr(struct OptConfData *data, const char **attr) | |
| { | |
| uint32_t i; | |
| const char *engine_name_match = NULL, *engine_versions = NULL; | |
| driOptionInfo version_range = { | |
| .type = DRI_INT, | |
| }; | |
| for (i = 0; attr[i]; i += 2) { | |
| if (!strcmp(attr[i], "name")) /* not needed here */; | |
| else if (!strcmp(attr[i], "engine_name_match")) engine_name_match = attr[i+1]; | |
| else if (!strcmp(attr[i], "engine_versions")) engine_versions = attr[i+1]; | |
| else XML_WARNING("unknown application attribute: %s.", attr[i]); | |
| } | |
| if (engine_name_match) { | |
| regex_t re; | |
| if (regcomp(&re, engine_name_match, REG_EXTENDED|REG_NOSUB) == 0) { | |
| if (regexec(&re, data->engineName, 0, NULL, 0) == REG_NOMATCH) | |
| data->ignoringApp = data->inApp; | |
| regfree(&re); | |
| } else | |
| XML_WARNING("Invalid engine_name_match=\"%s\".", engine_name_match); | |
| } | |
| if (engine_versions) { | |
| driOptionValue v = { ._int = data->engineVersion }; | |
| if (parseRange(&version_range, engine_versions)) { | |
| if (!checkValue(&v, &version_range)) | |
| data->ignoringApp = data->inApp; | |
| } else { | |
| XML_WARNING("Failed to parse engine_versions range=\"%s\".", | |
| engine_versions); | |
| } | |
| } | |
| } | |
| /** \brief Parse attributes of a shader element. */ | |
| static void | |
| parseShaderAttr(struct OptConfData *data, const char **attr) | |
| { | |
| uint32_t i; | |
| const char *type = NULL, *hash = NULL; | |
| for (i = 0; attr[i]; i += 2) { | |
| if (!strcmp(attr[i], "type")) type = attr[i+1]; | |
| else if (!strcmp(attr[i], "hash")) hash = attr[i+1]; | |
| else XML_WARNING("unknown shader attribute: %s.", attr[i]); | |
| } | |
| if (!type) XML_WARNING1("type attribute missing in shader."); | |
| if (!hash) XML_WARNING1("hash attribute missing in shader."); | |
| if (type && hash) { | |
| if (!strcmp(type, "dxbc") || !strcmp(type, "dxil")) { | |
| data->shaderHash.u64 = strtoull(hash, NULL, 16); | |
| data->shaderHashSize = sizeof(data->shaderHash.u64); | |
| } else if (!strcmp(type, "spirv")) { | |
| if (strlen(hash) != (BLAKE3_HEX_LEN - 1)) { | |
| XML_WARNING("hash attribute value \"%s\" %u/%u not in blake3 format.", | |
| hash, strlen(hash), BLAKE3_HEX_LEN); | |
| } else { | |
| char blake3_str[BLAKE3_HEX_LEN] = {0}; | |
| for (unsigned i = 0; i < MIN2(strlen(hash), BLAKE3_HEX_LEN); i++) | |
| blake3_str[i] = tolower(hash[i]); | |
| _mesa_blake3_hex_to_blake3(data->shaderHash.blake3, blake3_str); | |
| data->shaderHashSize = sizeof(data->shaderHash.blake3); | |
| } | |
| } else { | |
| XML_WARNING("type attribute value \"%s\" invalid in shader (valid : spirv, dxbc, dxil).", | |
| type); | |
| } | |
| } | |
| } | |
| /** \brief Parse attributes of an option element. */ | |
| static void | |
| parseOptConfAttr(struct OptConfData *data, const char **attr) | |
| { | |
| uint32_t i; | |
| const char *name = NULL, *value = NULL; | |
| for (i = 0; attr[i]; i += 2) { | |
| if (!strcmp(attr[i], "name")) name = attr[i+1]; | |
| else if (!strcmp(attr[i], "value")) value = attr[i+1]; | |
| else XML_WARNING("unknown option attribute: %s.", attr[i]); | |
| } | |
| if (!name) XML_WARNING1("name attribute missing in option."); | |
| if (!value) XML_WARNING1("value attribute missing in option."); | |
| if (name && value) { | |
| driOptionCache *cache = data->cache; | |
| uint32_t opt = findOption(cache, name); | |
| if (cache->info[opt].name == NULL) | |
| /* don't use XML_WARNING, drirc defines options for all drivers, | |
| * but not all drivers support them */ | |
| return; | |
| else if (os_get_option(cache->info[opt].name)) { | |
| /* don't use XML_WARNING, we want the user to see this! */ | |
| if (be_verbose()) { | |
| fprintf(stderr, | |
| "ATTENTION: option value of option %s ignored.\n", | |
| cache->info[opt].name); | |
| } | |
| } else if (!parseValue(&cache->values[opt], cache->info[opt].type, value)) | |
| XML_WARNING("illegal option value: %s.", value); | |
| } | |
| } | |
| /** \brief Parse attributes of an option element for <shader>. */ | |
| static void | |
| parseShaderOptConfAttr(struct OptConfData *data, const char **attr) | |
| { | |
| uint32_t i; | |
| const char *name = NULL, *value = NULL; | |
| for (i = 0; attr[i]; i += 2) { | |
| if (!strcmp(attr[i], "name")) name = attr[i+1]; | |
| else if (!strcmp(attr[i], "value")) value = attr[i+1]; | |
| else XML_WARNING("unknown option attribute: %s.", attr[i]); | |
| } | |
| if (!name) XML_WARNING1("name attribute missing in option."); | |
| if (!value) XML_WARNING1("value attribute missing in option."); | |
| if (name && value && data->shaderHashSize != 0) { | |
| driOptionCache *cache = data->cache; | |
| uint32_t opt = findOption(cache, name); | |
| if (cache->info[opt].name == NULL) | |
| /* don't use XML_WARNING, drirc defines options for all drivers, | |
| * but not all drivers support them */ | |
| return; | |
| else if (os_get_option(cache->info[opt].name)) { | |
| /* don't use XML_WARNING, we want the user to see this! */ | |
| if (be_verbose()) { | |
| fprintf(stderr, | |
| "ATTENTION: option value of option %s ignored.\n", | |
| cache->info[opt].name); | |
| } | |
| } else if (!parseValue(&cache->values[opt], cache->info[opt].type, value)) { | |
| XML_WARNING("illegal option value: %s.", value); | |
| } else if (data->shaderOptionCallback != NULL) { | |
| data->shaderOptionCallback(&data->shaderHash, | |
| data->shaderHashSize, | |
| &cache->info[opt], | |
| &cache->values[opt], | |
| data->shaderOptionCallbackData); | |
| } | |
| } | |
| } | |
| #if WITH_XMLCONFIG | |
| /** \brief Elements in configuration files. */ | |
| enum OptConfElem { | |
| OC_APPLICATION = 0, OC_DEVICE, OC_DRICONF, OC_ENGINE, OC_OPTION, OC_SHADER, OC_COUNT | |
| }; | |
| static const char *OptConfElems[] = { | |
| [OC_APPLICATION] = "application", | |
| [OC_DEVICE] = "device", | |
| [OC_DRICONF] = "driconf", | |
| [OC_ENGINE] = "engine", | |
| [OC_OPTION] = "option", | |
| [OC_SHADER] = "shader", | |
| }; | |
| static int compare(const void *a, const void *b) { | |
| return strcmp(*(char *const*)a, *(char *const*)b); | |
| } | |
| /** \brief Binary search in a string array. */ | |
| static uint32_t | |
| bsearchStr(const char *name, const char *elems[], uint32_t count) | |
| { | |
| const char **found; | |
| found = bsearch(&name, elems, count, sizeof(char *), compare); | |
| if (found) | |
| return found - elems; | |
| else | |
| return count; | |
| } | |
| /** \brief Handler for start element events. */ | |
| static void | |
| optConfStartElem(void *userData, const char *name, | |
| const char **attr) | |
| { | |
| struct OptConfData *data = (struct OptConfData *)userData; | |
| enum OptConfElem elem = bsearchStr(name, OptConfElems, OC_COUNT); | |
| switch (elem) { | |
| case OC_DRICONF: | |
| if (data->inDriConf) | |
| XML_WARNING1("nested <driconf> elements."); | |
| if (attr[0]) | |
| XML_WARNING1("attributes specified on <driconf> element."); | |
| data->inDriConf++; | |
| break; | |
| case OC_DEVICE: | |
| if (!data->inDriConf) | |
| XML_WARNING1("<device> should be inside <driconf>."); | |
| if (data->inDevice) | |
| XML_WARNING1("nested <device> elements."); | |
| data->inDevice++; | |
| if (!data->ignoringDevice && !data->ignoringApp) | |
| parseDeviceAttr(data, attr); | |
| break; | |
| case OC_APPLICATION: | |
| if (!data->inDevice) | |
| XML_WARNING1("<application> should be inside <device>."); | |
| if (data->inApp) | |
| XML_WARNING1("nested <application> or <engine> elements."); | |
| data->inApp++; | |
| if (!data->ignoringDevice && !data->ignoringApp) | |
| parseAppAttr(data, attr); | |
| break; | |
| case OC_ENGINE: | |
| if (!data->inDevice) | |
| XML_WARNING1("<engine> should be inside <device>."); | |
| if (data->inApp) | |
| XML_WARNING1("nested <application> or <engine> elements."); | |
| data->inApp++; | |
| if (!data->ignoringDevice && !data->ignoringApp) | |
| parseEngineAttr(data, attr); | |
| break; | |
| case OC_SHADER: | |
| if (!data->inApp) | |
| XML_WARNING1("<shader> should be inside <application>."); | |
| if (data->inShader) | |
| XML_WARNING1("nested <shader> elements."); | |
| data->inShader++; | |
| if (!data->ignoringDevice && !data->ignoringApp) | |
| parseShaderAttr(data, attr); | |
| break; | |
| case OC_OPTION: | |
| if (!data->inApp && !data->inShader) | |
| XML_WARNING1("<option> should be inside <application> or <shader>."); | |
| if (data->inOption) | |
| XML_WARNING1("nested <option> elements."); | |
| data->inOption++; | |
| if (!data->ignoringDevice && !data->ignoringApp) { | |
| if (data->inShader) | |
| parseShaderOptConfAttr(data, attr); | |
| else | |
| parseOptConfAttr(data, attr); | |
| } | |
| break; | |
| default: | |
| XML_WARNING("unknown element: %s.", name); | |
| } | |
| } | |
| /** \brief Handler for end element events. */ | |
| static void | |
| optConfEndElem(void *userData, const char *name) | |
| { | |
| struct OptConfData *data = (struct OptConfData *)userData; | |
| enum OptConfElem elem = bsearchStr(name, OptConfElems, OC_COUNT); | |
| switch (elem) { | |
| case OC_DRICONF: | |
| data->inDriConf--; | |
| break; | |
| case OC_DEVICE: | |
| if (data->inDevice-- == data->ignoringDevice) | |
| data->ignoringDevice = 0; | |
| break; | |
| case OC_APPLICATION: | |
| case OC_ENGINE: | |
| if (data->inApp-- == data->ignoringApp) | |
| data->ignoringApp = 0; | |
| break; | |
| case OC_SHADER: | |
| data->inShader--; | |
| data->shaderHashSize = 0; | |
| break; | |
| case OC_OPTION: | |
| data->inOption--; | |
| break; | |
| default: | |
| /* unknown element, warning was produced on start tag */; | |
| } | |
| } | |
| static void | |
| _parseOneConfigFile(XML_Parser p) | |
| { | |
| #define BUF_SIZE 0x1000 | |
| struct OptConfData *data = (struct OptConfData *)XML_GetUserData(p); | |
| int status; | |
| int fd; | |
| if ((fd = open(data->name, O_RDONLY)) == -1) { | |
| __driUtilMessage("Can't open configuration file %s: %s.", | |
| data->name, strerror(errno)); | |
| return; | |
| } | |
| while (1) { | |
| int bytesRead; | |
| void *buffer = XML_GetBuffer(p, BUF_SIZE); | |
| if (!buffer) { | |
| __driUtilMessage("Can't allocate parser buffer."); | |
| break; | |
| } | |
| bytesRead = read(fd, buffer, BUF_SIZE); | |
| if (bytesRead == -1) { | |
| __driUtilMessage("Error reading from configuration file %s: %s.", | |
| data->name, strerror(errno)); | |
| break; | |
| } | |
| status = XML_ParseBuffer(p, bytesRead, bytesRead == 0); | |
| if (!status) { | |
| XML_ERROR("%s.", XML_ErrorString(XML_GetErrorCode(p))); | |
| break; | |
| } | |
| if (bytesRead == 0) | |
| break; | |
| } | |
| close(fd); | |
| #undef BUF_SIZE | |
| } | |
| /** \brief Parse the named configuration file */ | |
| static void | |
| parseOneConfigFile(struct OptConfData *data, const char *filename) | |
| { | |
| XML_Parser p; | |
| p = XML_ParserCreate(NULL); /* use encoding specified by file */ | |
| XML_SetElementHandler(p, optConfStartElem, optConfEndElem); | |
| XML_SetUserData(p, data); | |
| data->parser = p; | |
| data->name = filename; | |
| data->ignoringDevice = 0; | |
| data->ignoringApp = 0; | |
| data->inDriConf = 0; | |
| data->inDevice = 0; | |
| data->inApp = 0; | |
| data->inOption = 0; | |
| _parseOneConfigFile(p); | |
| XML_ParserFree(p); | |
| } | |
| static int | |
| scandir_filter(const struct dirent *ent) | |
| { | |
| #ifndef DT_REG /* systems without d_type in dirent results */ | |
| struct stat st; | |
| if ((lstat(ent->d_name, &st) != 0) || | |
| (!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode))) | |
| return 0; | |
| #else | |
| /* Allow through unknown file types for filesystems that don't support d_type | |
| * The full filepath isn't available here to stat the file | |
| */ | |
| if (ent->d_type != DT_REG && ent->d_type != DT_LNK && ent->d_type != DT_UNKNOWN) | |
| return 0; | |
| #endif | |
| int len = strlen(ent->d_name); | |
| if (len <= 5 || strcmp(ent->d_name + len - 5, ".conf")) | |
| return 0; | |
| return 1; | |
| } | |
| /** \brief Parse configuration files in a directory */ | |
| static void | |
| parseConfigDir(struct OptConfData *data, const char *dirname) | |
| { | |
| int i, count; | |
| struct dirent **entries = NULL; | |
| count = scandir(dirname, &entries, scandir_filter, alphasort); | |
| if (count < 0) | |
| return; | |
| for (i = 0; i < count; i++) { | |
| char filename[PATH_MAX]; | |
| #ifdef DT_REG | |
| unsigned char d_type = entries[i]->d_type; | |
| #endif | |
| snprintf(filename, PATH_MAX, "%s/%s", dirname, entries[i]->d_name); | |
| free(entries[i]); | |
| #ifdef DT_REG | |
| /* In the case of unknown d_type, ensure it is a regular file | |
| * This can be accomplished with stat on the full filepath | |
| */ | |
| if (d_type == DT_UNKNOWN) { | |
| struct stat st; | |
| if (stat(filename, &st) != 0 || | |
| !S_ISREG(st.st_mode)) { | |
| continue; | |
| } | |
| } | |
| #endif | |
| parseOneConfigFile(data, filename); | |
| } | |
| free(entries); | |
| } | |
| #else | |
| # include "driconf_static.h" | |
| static void | |
| parseStaticOptions(struct OptConfData *data, const struct driconf_option *options, | |
| unsigned num_options) | |
| { | |
| if (data->ignoringDevice || data->ignoringApp) | |
| return; | |
| for (unsigned i = 0; i < num_options; i++) { | |
| const char *optattr[] = { | |
| "name", options[i].name, | |
| "value", options[i].value, | |
| NULL | |
| }; | |
| parseOptConfAttr(data, optattr); | |
| } | |
| } | |
| static void | |
| parseStaticConfig(struct OptConfData *data) | |
| { | |
| data->ignoringDevice = 0; | |
| data->ignoringApp = 0; | |
| data->inDriConf = 0; | |
| data->inDevice = 0; | |
| data->inApp = 0; | |
| data->inOption = 0; | |
| for (unsigned i = 0; i < ARRAY_SIZE(driconf); i++) { | |
| const struct driconf_device *d = driconf[i]; | |
| const char *devattr[] = { | |
| "driver", d->driver, | |
| "device", d->device, | |
| NULL | |
| }; | |
| data->ignoringDevice = 0; | |
| data->inDevice++; | |
| parseDeviceAttr(data, devattr); | |
| data->inDevice--; | |
| data->inApp++; | |
| for (unsigned j = 0; j < d->num_engines; j++) { | |
| const struct driconf_engine *e = &d->engines[j]; | |
| const char *engattr[] = { | |
| "engine_name_match", e->engine_name_match, | |
| "engine_versions", e->engine_versions, | |
| NULL | |
| }; | |
| data->ignoringApp = 0; | |
| parseEngineAttr(data, engattr); | |
| parseStaticOptions(data, e->options, e->num_options); | |
| } | |
| for (unsigned j = 0; j < d->num_applications; j++) { | |
| const struct driconf_application *a = &d->applications[j]; | |
| const char *appattr[] = { | |
| "name", a->name, | |
| "executable", a->executable, | |
| "executable_regexp", a->executable_regexp, | |
| "blake3", a->blake3, | |
| "application_name_match", a->application_name_match, | |
| "application_versions", a->application_versions, | |
| NULL | |
| }; | |
| data->ignoringApp = 0; | |
| parseAppAttr(data, appattr); | |
| parseStaticOptions(data, a->options, a->num_options); | |
| } | |
| data->inApp--; | |
| } | |
| } | |
| #endif /* WITH_XMLCONFIG */ | |
| /** \brief Initialize an option cache based on info */ | |
| static void | |
| initOptionCache(driOptionCache *cache, const driOptionCache *info) | |
| { | |
| unsigned i, size = 1 << info->tableSize; | |
| cache->info = info->info; | |
| cache->tableSize = info->tableSize; | |
| cache->values = malloc(((size_t)1 << info->tableSize) * sizeof(driOptionValue)); | |
| if (cache->values == NULL) { | |
| fprintf(stderr, "%s: %d: out of memory.\n", __FILE__, __LINE__); | |
| abort(); | |
| } | |
| memcpy(cache->values, info->values, | |
| ((size_t)1 << info->tableSize) * sizeof(driOptionValue)); | |
| for (i = 0; i < size; ++i) { | |
| if (cache->info[i].type == DRI_STRING) | |
| XSTRDUP(cache->values[i]._string, info->values[i]._string); | |
| } | |
| } | |
| static const char *execname; | |
| void | |
| driInjectExecName(const char *exec) | |
| { | |
| execname = exec; | |
| } | |
| static void | |
| driLogNonDefaultOptions(const driOptionCache *cache, | |
| const driOptionCache *defaults, | |
| const char *tag) | |
| { | |
| assert(cache->tableSize == defaults->tableSize); | |
| assert(cache->info == defaults->info); | |
| for (unsigned i = 0; i < (1u << cache->tableSize); i++) { | |
| const driOptionInfo *info = &cache->info[i]; | |
| if (!info->name) | |
| continue; | |
| const driOptionValue *value = &cache->values[i]; | |
| const driOptionValue *default_value = &defaults->values[i]; | |
| switch (info->type) { | |
| case DRI_BOOL: | |
| if (value->_bool != default_value->_bool) | |
| mesa_log(MESA_LOG_INFO, tag, "drirc: %s=%s", info->name, | |
| value->_bool ? "true" : "false"); | |
| break; | |
| case DRI_ENUM: | |
| case DRI_INT: | |
| if (value->_int != default_value->_int) | |
| mesa_log(MESA_LOG_INFO, tag, "drirc: %s=%d", info->name, value->_int); | |
| break; | |
| case DRI_UINT64: | |
| if (value->_uint64 != default_value->_uint64) | |
| mesa_log(MESA_LOG_INFO, tag, "drirc: %s=%" PRIu64, info->name, value->_uint64); | |
| break; | |
| case DRI_FLOAT: | |
| if (value->_float != default_value->_float) | |
| mesa_log(MESA_LOG_INFO, tag, "drirc: %s=%g", info->name, value->_float); | |
| break; | |
| case DRI_STRING: | |
| if (strcmp(value->_string, default_value->_string)) | |
| mesa_log(MESA_LOG_INFO, tag, "drirc: %s=%s", info->name, value->_string); | |
| break; | |
| case DRI_SECTION: | |
| break; | |
| } | |
| } | |
| } | |
| void | |
| driParseConfigFiles(driOptionCache *cache, const driOptionCache *info, | |
| const driConfigFileParseParams *params) | |
| { | |
| initOptionCache(cache, info); | |
| struct OptConfData userData = {0}; | |
| if (!execname) | |
| execname = os_get_option("MESA_DRICONF_EXECUTABLE_OVERRIDE"); | |
| if (!execname) | |
| execname = util_get_process_name(); | |
| userData.cache = cache; | |
| userData.screenNum = params->screenNum; | |
| userData.driverName = params->driverName; | |
| userData.kernelDriverName = params->kernelDriverName; | |
| userData.deviceName = params->deviceName; | |
| userData.deviceVersion = params->deviceVersion; | |
| userData.applicationName = params->applicationName ? params->applicationName : ""; | |
| userData.applicationVersion = params->applicationVersion; | |
| userData.engineName = params->engineName ? params->engineName : ""; | |
| userData.engineVersion = params->engineVersion; | |
| userData.execName = execname; | |
| userData.shaderOptionCallback = params->shaderOptionCallback; | |
| userData.shaderOptionCallbackData = params->shaderOptionCallbackData; | |
| #if WITH_XMLCONFIG | |
| const char *configdir; | |
| const char *home; | |
| /* parse from either $DRIRC_CONFIGDIR or $datadir/drirc.d */ | |
| if ((configdir = os_get_option("DRIRC_CONFIGDIR"))) { | |
| for (size_t len; len = strcspn(configdir, ":"), *configdir; configdir += MAX2(1, len)) { | |
| if (!len) | |
| continue; | |
| char *dir = strndup(configdir, len); | |
| parseConfigDir(&userData, dir); | |
| free(dir); | |
| } | |
| } else { | |
| parseConfigDir(&userData, DATADIR "/drirc.d"); | |
| parseOneConfigFile(&userData, SYSCONFDIR "/drirc"); | |
| } | |
| if ((home = os_get_option("HOME"))) { | |
| char filename[PATH_MAX]; | |
| snprintf(filename, PATH_MAX, "%s/.drirc", home); | |
| parseOneConfigFile(&userData, filename); | |
| } | |
| #else | |
| parseStaticConfig(&userData); | |
| #endif /* WITH_XMLCONFIG */ | |
| if (params->logNonDefaultOptions) | |
| driLogNonDefaultOptions(cache, info, params->driverName); | |
| } | |
| void | |
| driDestroyOptionInfo(driOptionCache *info) | |
| { | |
| driDestroyOptionCache(info); | |
| if (info->info) { | |
| uint32_t i, size = 1 << info->tableSize; | |
| for (i = 0; i < size; ++i) { | |
| free(info->info[i].name); | |
| } | |
| free(info->info); | |
| } | |
| } | |
| void | |
| driDestroyOptionCache(driOptionCache *cache) | |
| { | |
| if (cache->info) { | |
| unsigned i, size = 1 << cache->tableSize; | |
| for (i = 0; i < size; ++i) { | |
| if (cache->info[i].type == DRI_STRING) | |
| free(cache->values[i]._string); | |
| } | |
| } | |
| free(cache->values); | |
| } | |
| unsigned char | |
| driCheckOption(const driOptionCache *cache, const char *name, | |
| driOptionType type) | |
| { | |
| uint32_t i = findOption(cache, name); | |
| return cache->info[i].name != NULL && cache->info[i].type == type; | |
| } | |
| unsigned char | |
| driQueryOptionb(const driOptionCache *cache, const char *name) | |
| { | |
| uint32_t i = findOption(cache, name); | |
| /* make sure the option is defined and has the correct type */ | |
| assert(cache->info[i].name != NULL); | |
| assert(cache->info[i].type == DRI_BOOL); | |
| return cache->values[i]._bool; | |
| } | |
| int | |
| driQueryOptioni(const driOptionCache *cache, const char *name) | |
| { | |
| uint32_t i = findOption(cache, name); | |
| /* make sure the option is defined and has the correct type */ | |
| assert(cache->info[i].name != NULL); | |
| assert(cache->info[i].type == DRI_INT || cache->info[i].type == DRI_ENUM); | |
| return cache->values[i]._int; | |
| } | |
| uint64_t | |
| driQueryOptionu64(const driOptionCache *cache, const char *name) | |
| { | |
| uint32_t i = findOption(cache, name); | |
| /* make sure the option is defined and has the correct type */ | |
| assert(cache->info[i].name != NULL); | |
| assert(cache->info[i].type == DRI_UINT64); | |
| return cache->values[i]._uint64; | |
| } | |
| float | |
| driQueryOptionf(const driOptionCache *cache, const char *name) | |
| { | |
| uint32_t i = findOption(cache, name); | |
| /* make sure the option is defined and has the correct type */ | |
| assert(cache->info[i].name != NULL); | |
| assert(cache->info[i].type == DRI_FLOAT); | |
| return cache->values[i]._float; | |
| } | |
| char * | |
| driQueryOptionstr(const driOptionCache *cache, const char *name) | |
| { | |
| uint32_t i = findOption(cache, name); | |
| /* make sure the option is defined and has the correct type */ | |
| assert(cache->info[i].name != NULL); | |
| assert(cache->info[i].type == DRI_STRING); | |
| return cache->values[i]._string; | |
| } |