#include #include "util.h" #include "debug.h" #include "demangle-rust.h" /* * Mangled Rust symbols look like this: * * _$LT$std..sys..fd..FileDesc$u20$as$u20$core..ops..Drop$GT$::drop::hc68340e1baa4987a * * The original symbol is: * * ::drop * * The last component of the path is a 64-bit hash in lowercase hex, prefixed * with "h". Rust does not have a global namespace between crates, an illusion * which Rust maintains by using the hash to distinguish things that would * otherwise have the same symbol. * * Any path component not starting with a XID_Start character is prefixed with * "_". * * The following escape sequences are used: * * "," => $C$ * "@" => $SP$ * "*" => $BP$ * "&" => $RF$ * "<" => $LT$ * ">" => $GT$ * "(" => $LP$ * ")" => $RP$ * " " => $u20$ * "'" => $u27$ * "[" => $u5b$ * "]" => $u5d$ * "~" => $u7e$ * * A double ".." means "::" and a single "." means "-". * * The only characters allowed in the mangled symbol are a-zA-Z0-9 and _.:$ */ static const char *hash_prefix = "::h"; static const size_t hash_prefix_len = 3; static const size_t hash_len = 16; static bool is_prefixed_hash(const char *start); static bool looks_like_rust(const char *sym, size_t len); static bool unescape(const char **in, char **out, const char *seq, char value); /* * INPUT: * sym: symbol that has been through BFD-demangling * * This function looks for the following indicators: * * 1. The hash must consist of "h" followed by 16 lowercase hex digits. * * 2. As a sanity check, the hash must use between 5 and 15 of the 16 possible * hex digits. This is true of 99.9998% of hashes so once in your life you * may see a false negative. The point is to notice path components that * could be Rust hashes but are probably not, like "haaaaaaaaaaaaaaaa". In * this case a false positive (non-Rust symbol has an important path * component removed because it looks like a Rust hash) is worse than a * false negative (the rare Rust symbol is not demangled) so this sets the * balance in favor of false negatives. * * 3. There must be no characters other than a-zA-Z0-9 and _.:$ * * 4. There must be no unrecognized $-sign sequences. * * 5. There must be no sequence of three or more dots in a row ("..."). */ bool rust_is_mangled(const char *sym) { size_t len, len_without_hash; if (!sym) return false; len = strlen(sym); if (len <= hash_prefix_len + hash_len) /* Not long enough to contain "::h" + hash + something else */ return false; len_without_hash = len - (hash_prefix_len + hash_len); if (!is_prefixed_hash(sym + len_without_hash)) return false; return looks_like_rust(sym, len_without_hash); } /* * A hash is the prefix "::h" followed by 16 lowercase hex digits. The hex * digits must comprise between 5 and 15 (inclusive) distinct digits. */ static bool is_prefixed_hash(const char *str) { const char *end; bool seen[16]; size_t i; int count; if (strncmp(str, hash_prefix, hash_prefix_len)) return false; str += hash_prefix_len; memset(seen, false, sizeof(seen)); for (end = str + hash_len; str < end; str++) if (*str >= '0' && *str <= '9') seen[*str - '0'] = true; else if (*str >= 'a' && *str <= 'f') seen[*str - 'a' + 10] = true; else return false; /* Count how many distinct digits seen */ count = 0; for (i = 0; i < 16; i++) if (seen[i]) count++; return count >= 5 && count <= 15; } static bool looks_like_rust(const char *str, size_t len) { const char *end = str + len; while (str < end) switch (*str) { case '$': if (!strncmp(str, "$C$", 3)) str += 3; else if (!strncmp(str, "$SP$", 4) || !strncmp(str, "$BP$", 4) || !strncmp(str, "$RF$", 4) || !strncmp(str, "$LT$", 4) || !strncmp(str, "$GT$", 4) || !strncmp(str, "$LP$", 4) || !strncmp(str, "$RP$", 4)) str += 4; else if (!strncmp(str, "$u20$", 5) || !strncmp(str, "$u27$", 5) || !strncmp(str, "$u5b$", 5) || !strncmp(str, "$u5d$", 5) || !strncmp(str, "$u7e$", 5)) str += 5; else return false; break; case '.': /* Do not allow three or more consecutive dots */ if (!strncmp(str, "...", 3)) return false; /* Fall through */ case 'a' ... 'z': case 'A' ... 'Z': case '0' ... '9': case '_': case ':': str++; break; default: return false; } return true; } /* * INPUT: * sym: symbol for which rust_is_mangled(sym) returns true * * The input is demangled in-place because the mangled name is always longer * than the demangled one. */ void rust_demangle_sym(char *sym) { const char *in; char *out; const char *end; if (!sym) return; in = sym; out = sym; end = sym + strlen(sym) - (hash_prefix_len + hash_len); while (in < end) switch (*in) { case '$': if (!(unescape(&in, &out, "$C$", ',') || unescape(&in, &out, "$SP$", '@') || unescape(&in, &out, "$BP$", '*') || unescape(&in, &out, "$RF$", '&') || unescape(&in, &out, "$LT$", '<') || unescape(&in, &out, "$GT$", '>') || unescape(&in, &out, "$LP$", '(') || unescape(&in, &out, "$RP$", ')') || unescape(&in, &out, "$u20$", ' ') || unescape(&in, &out, "$u27$", '\'') || unescape(&in, &out, "$u5b$", '[') || unescape(&in, &out, "$u5d$", ']') || unescape(&in, &out, "$u7e$", '~'))) { pr_err("demangle-rust: unexpected escape sequence"); goto done; } break; case '_': /* * If this is the start of a path component and the next * character is an escape sequence, ignore the * underscore. The mangler inserts an underscore to make * sure the path component begins with a XID_Start * character. */ if ((in == sym || in[-1] == ':') && in[1] == '$') in++; else *out++ = *in++; break; case '.': if (in[1] == '.') { /* ".." becomes "::" */ *out++ = ':'; *out++ = ':'; in += 2; } else { /* "." becomes "-" */ *out++ = '-'; in++; } break; case 'a' ... 'z': case 'A' ... 'Z': case '0' ... '9': case ':': *out++ = *in++; break; default: pr_err("demangle-rust: unexpected character '%c' in symbol\n", *in); goto done; } done: *out = '\0'; } static bool unescape(const char **in, char **out, const char *seq, char value) { size_t len = strlen(seq); if (strncmp(*in, seq, len)) return false; **out = value; *in += len; *out += 1; return true; } /tr>
x86/mce: Make timer handling more robust
Erik reported that on a preproduction hardware a CMCI storm triggers the BUG_ON in add_timer_on(). The reason is that the per CPU MCE timer is started by the CMCI logic before the MCE CPU hotplug callback starts the timer with add_timer_on(). So the timer is already queued which triggers the BUG. Using add_timer_on() is pretty pointless in this code because the timer is strictlty per CPU, initialized as pinned and all operations which arm the timer happen on the CPU to which the timer belongs. Simplify the whole machinery by using mod_timer() instead of add_timer_on() which avoids the problem because mod_timer() can handle already queued timers. Use __start_timer() everywhere so the earliest armed expiry time is preserved. Reported-by: Erik Veijola <erik.veijola@intel.com> Tested-by: Borislav Petkov <bp@alien8.de> Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Borislav Petkov <bp@alien8.de> Cc: Tony Luck <tony.luck@intel.com> Link: http://lkml.kernel.org/r/alpine.DEB.2.20.1701310936080.3457@nanos Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Diffstat (limited to 'sound/soc/blackfin/bf6xx-i2s.c')