/*

    Copyright (C) 2011  ABRT team

    Copyright (C) 2011  RedHat Inc

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along

    with this program; if not, write to the Free Software Foundation, Inc.,

    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#include <satyr/stacktrace.h>

#include <satyr/thread.h>

#include <regex.h>

#define _GNU_SOURCE 1 /* for strcasestr */

#include "libabrt.h"

/* Used to be 100, but some MCE oopses are short:

 * "CPU 0: Machine Check Exception: 0000000000000007"

 */

#define SANE_MIN_OOPS_LEN 30

static void record_oops(GList **oops_list, const struct abrt_koops_line_info* lines_info, int oopsstart, int oopsend)

{

    int q;

    int len;

    int rv = 1;

    len = 2;

    for (q = oopsstart; q <= oopsend; q++)

        len += strlen(lines_info[q].ptr) + 1;

    /* too short oopses are invalid */

    if (len > SANE_MIN_OOPS_LEN)

    {

        char *oops = (char*)xzalloc(len);

        char *dst = oops;

        char *version = NULL;

        for (q = oopsstart; q <= oopsend; q++)

        {

            if (!version)

                version = koops_extract_version(lines_info[q].ptr);

            if (lines_info[q].ptr[0])

            {

                dst = stpcpy(dst, lines_info[q].ptr);

                dst = stpcpy(dst, "\n");

            }

        }

        if ((dst - oops) > SANE_MIN_OOPS_LEN)

        {

            *oops_list = g_list_append(

                        *oops_list,

                        xasprintf("%s\n%s", (version ? version : ""), oops)

            );

        }

        else

        {

            /* too short oopses are invalid */

            rv = 0;

        }

        free(oops);

        free(version);

    }

    VERB3 if (rv == 0) log_warning("Dropped oops: too short");

}

/* In some comparisons, we skip 1st letter, to avoid dealing with

 * changes in capitalization in kernel. For example, I see that

 * current kernel git (at 2011-01-01) has both "kernel BUG at ..."

 * and "Kernel BUG at ..." messages, and I don't want to change

 * the code below whenever kernel is changed to use "K" (or "k")

 * uniformly.

 */

static const char *const s_koops_suspicious_strings[] = {

    "BUG:",

    "WARNING: at",

    "WARNING: CPU:",

    "INFO: possible recursive locking detected",

    /*k*/"ernel BUG at",

    "list_del corruption",

    "list_add corruption",

    "do_IRQ: stack overflow:",

    /*n*/"ear stack overflow (cur:",

    /*g*/"eneral protection fault",

    /*u*/"nable to handle kernel",

    /*d*/"ouble fault:",

    "RTNL: assertion failed",

    /*e*/"eek! page_mapcount(page) went negative!",

    /*b*/"adness at",

    "NETDEV WATCHDOG",

    /*s*/"ysctl table check failed",

    ": nobody cared",

    "IRQ handler type mismatch",

    "Kernel panic - not syncing:",

    /*

     * MCE examples for various CPUs/architectures (collected 2013-04):

     * arch/arc/kernel/traps.c:			die("Machine Check Exception", regs, address, cause);

     * arch/x86/kernel/cpu/mcheck/winchip.c:	printk(KERN_EMERG "CPU0: Machine Check Exception.\n");

     * arch/x86/kernel/cpu/mcheck/p5.c:		"CPU#%d: Machine Check Exception:  0x%8X (type 0x%8X).\n",

     * arch/x86/kernel/cpu/mcheck/mce.c:	pr_emerg(HW_ERR "CPU %d: Machine Check Exception: %Lx Bank %d: %016Lx\n",

     * drivers/edac/sb_edac.c:			printk("CPU %d: Machine Check Exception: %Lx Bank %d: %016Lx\n",

     *

     * MCEs can be fatal (they panic kernel) or not.

     * Fatal MCE are delivered as exception#18 to the CPU.

     * Non-fatal ones sometimes are delivered as exception#18;

     * other times they are silently recorded in magic MSRs, CPU is not alerted.

     * Linux kernel periodically (up to 5 mins interval) reads those MSRs

     * and if MCE is seen there, it is piped in binary form through

     * /dev/mcelog to whoever listens on it. (Such as mcelog tool in --daemon

     * mode; but cat 

     *

     * "Machine Check Exception:" message is printed *only*

     * by fatal MCEs (so far, future kernels may be different).

     * It will be caught as vmcore if kdump is configured.

     *

     * Non-fatal MCEs have "[Hardware Error]: Machine check events logged"

     * message in kernel log.

     * When /dev/mcelog is read, *no additional kernel log messages appear*:

     * if we want more readable data, we must rely on other tools

     * (such as mcelog daemon consuming binary /dev/mcelog and writing

     * human-readable /var/log/mcelog).

     */

    "Machine Check Exception:",

    "Machine check events logged",

    /* X86 TRAPs */

    "divide error:",

    "bounds:",

    "coprocessor segment overrun:",

    "invalid TSS:",

    "segment not present:",

    "invalid opcode",

    "alignment check:",

    "stack segment:",

    "fpu exception:",

    "simd exception:",

    "iret exception:",

    /* Termination */

    NULL

};

static const char *const s_koops_suspicious_strings_blacklist[] = {

    /* "BUG:" and "DEBUG:" overlaps, we don't want to recognize DEBUG messages as BUG */

    "DEBUG:",

    /* Termination */

    NULL

};

static bool suspicious_line(const char *line)

{

    const char *const *str = s_koops_suspicious_strings;

    for ( ; *str; ++str)

        if (strstr(line, *str))

            break;

    if (!*str)

        return false;

    str = s_koops_suspicious_strings_blacklist;

    for ( ; *str; ++str)

        if (strstr(line, *str))

           break;

    return !*str;

}

void koops_print_suspicious_strings(void)

{

    koops_print_suspicious_strings_filtered(NULL);

}

GList *koops_suspicious_strings_list(void)

{

    GList *strings = NULL;

    for (const char *const *str = s_koops_suspicious_strings; *str; ++str)

        strings = g_list_prepend(strings, (gpointer)*str);

    return strings;

}

GList *koops_suspicious_strings_blacklist(void)

{

    GList *strings = NULL;

    for (const char *const *str = s_koops_suspicious_strings_blacklist; *str; ++str)

        strings = g_list_prepend(strings, (gpointer)*str);

    return strings;

}

static bool match_any(const regex_t **res, const char *str)

{

    for (const regex_t **r = res; *r != NULL; ++r)

    {

        /* Regular expressions compiled with REG_NOSUB */

        const int reti = regexec(*r, str, 0, NULL, 0);

        if (reti == 0)

            return true;

        else if (reti != REG_NOMATCH)

        {

            char msgbuf[100];

            regerror(reti, *r, msgbuf, sizeof(msgbuf));

            error_msg_and_die("Regex match failed: %s", msgbuf);

        }

    }

    return false;

}

void koops_print_suspicious_strings_filtered(const regex_t **filterout)

{

    for (const char *const *str = s_koops_suspicious_strings; *str; ++str)

    {

        if (filterout == NULL || !match_any(filterout, *str))

            puts(*str);

    }

}

void koops_line_skip_jiffies(const char **c)

{

    /* remove jiffies time stamp counter if present

     * jiffies are unsigned long, so it can be 2^64 long, which is

     * 20 decimal digits

     */

    if (**c == '[')

    {

        const char *c2 = strchr(*c, '.');

        const char *c3 = strchr(*c, ']');

        if (c2 && c3 && (c2 < c3) && (c3-*c) < 21)

        {

            *c = c3 + 1;

            if (**c == ' ')

                (*c)++;

        }

    }

}

int koops_line_skip_level(const char **c)

{

    int linelevel = 0;

    if (**c == '<')

    {

        const char *ptr = *c + 1;

        while (isdigit(*ptr))

            ++ptr;

        if (*ptr == '>' && (ptr - *c > 1))

        {

            const char *const bck = ptr + 1;

            unsigned exp = 1;

            while (--ptr != *c)

            {

                linelevel += (*ptr - '0') * exp;

                exp *= 10;

            }

            *c = bck;

        }

    }

    return linelevel;

}

void koops_extract_oopses(GList **oops_list, char *buffer, size_t buflen)

{

    char *c;

    int linecount = 0;

    int lines_info_size = 0;

    struct abrt_koops_line_info *lines_info = NULL;

    /* Split buffer into lines */

    if (buflen != 0)

            buffer[buflen - 1] = '\n';  /* the buffer usually ends with \n, but let's make sure */

    c = buffer;

    while (c < buffer + buflen)

    {

        char linelevel;

        char *c9;

        char *colon;

        linecount++;

        c9 = (char*)memchr(c, '\n', buffer + buflen - c); /* a \n will always be found */

        assert(c9);

        *c9 = '\0'; /* turn the \n into a string termination */

        if (c9 == c)

            goto next_line;

        /* Is it a syslog file (/var/log/messages or similar)?

         * Even though _usually_ it looks like "Nov 19 12:34:38 localhost kernel: xxx",

         * some users run syslog in non-C locale:

         * "2010-02-22T09:24:08.156534-08:00 gnu-4 gnome-session[2048]: blah blah"

         *  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ !!!

         * We detect it by checking for N:NN:NN pattern in first 15 chars

         * (and this still is not good enough... false positive: "pci 0000:15:00.0: PME# disabled")

         */

        colon = strchr(c, ':');

        if (colon && colon > c && colon < c + 15

         && isdigit(colon[-1]) /* N:... */

         && isdigit(colon[1]) /* ...N:NN:... */

         && isdigit(colon[2])

         && colon[3] == ':'

         && isdigit(colon[4]) /* ...N:NN:NN... */

         && isdigit(colon[5])

        ) {

            /* It's syslog file, not a bare dmesg */

            /* Skip non-kernel lines */

            char *kernel_str = strstr(c, "kernel: ");

            if (!kernel_str)

            {

                /* if we see our own marker:

                 * "hostname abrt: Kerneloops: Reported 1 kernel oopses to Abrt"

                 * we know we submitted everything upto here already */

                if (strstr(c, "kernel oopses to Abrt"))

                {

                    log_debug("Found our marker at line %d", linecount);

                    free(lines_info);

                    lines_info = NULL;

                    lines_info_size = 0;

                    list_free_with_free(*oops_list);

                    *oops_list = NULL;

                }

                goto next_line;

            }

            c = kernel_str + sizeof("kernel: ")-1;

        }

        /* store and remove kernel log level */

        linelevel = koops_line_skip_level((const char **)&c);

        koops_line_skip_jiffies((const char **)&c);

        if ((lines_info_size & 0xfff) == 0)

        {

            lines_info = xrealloc(lines_info, (lines_info_size + 0x1000) * sizeof(lines_info[0]));

        }

        lines_info[lines_info_size].ptr = c;

        lines_info[lines_info_size].level = linelevel;

        lines_info_size++;

next_line:

        c = c9 + 1;

    }

    koops_extract_oopses_from_lines(oops_list, lines_info, lines_info_size);

    free(lines_info);

}

void koops_extract_oopses_from_lines(GList **oops_list, const struct abrt_koops_line_info *lines_info, int lines_info_size)

{

    /* Analyze lines */

    int i;

    char prevlevel = 0;

    int oopsstart = -1;

    int inbacktrace = 0;

    regex_t arm_regex;

    int arm_regex_rc = 0;

    /* ARM backtrace regex, match a string similar to r7:df912310 */

    arm_regex_rc = regcomp(&arm_regex, "r[[:digit:]]{1,}:[a-f[:digit:]]{8}", REG_EXTENDED | REG_NOSUB);

    i = 0;

    while (i < lines_info_size)

    {

        char *curline = lines_info[i].ptr;

        if (curline == NULL)

        {

            i++;

            continue;

        }

        while (*curline == ' ')

            curline++;

        if (oopsstart < 0)

        {

            /* Find start-of-oops markers */

            if (suspicious_line(curline))

                oopsstart = i;

            if (oopsstart >= 0)

            {

                /* debug information */

                log_debug("Found oops at line %d: '%s'", oopsstart, lines_info[oopsstart].ptr);

                /* try to find the end marker */

                int i2 = i + 1;

                while (i2 < lines_info_size && i2 < (i+50))

                {

                    if (strstr(lines_info[i2].ptr, "---[ end trace"))

                    {

                        inbacktrace = 1;

                        i = i2;

                        break;

                    }

                    i2++;

                }

            }

        }

        /* Are we entering a call trace part? */

        /* a call trace starts with "Call Trace:" or with the " [<.......>] function+0xFF/0xAA" pattern */

        if (oopsstart >= 0 && !inbacktrace)

        {

            if (strcasestr(curline, "Call Trace:")) /* yes, it must be case-insensitive */

                inbacktrace = 1;

            else

            /* Fatal MCE's have a few lines of useful information between

             * first "Machine check exception:" line and the final "Kernel panic"

             * line. Such oops, of course, is only detectable in kdumps (tested)

             * or possibly pstore-saved logs (I did not try this yet).

             * In order to capture all these lines, we treat final line

             * as "backtrace" (which is admittedly a hack):

             */

            if (strstr(curline, "Kernel panic - not syncing:") && strcasestr(curline, "Machine check"))

                inbacktrace = 1;

            else

            if (strnlen(curline, 9) > 8

             && (  (curline[0] == '(' && curline[1] == '[' && curline[2] == '<')

                || (curline[0] == '[' && curline[1] == '<'))

             && strstr(curline, ">]")

             && strstr(curline, "+0x")

             && strstr(curline, "/0x")

            ) {

                inbacktrace = 1;

            }

        }

        /* Are we at the end of an oops? */

        else if (oopsstart >= 0 && inbacktrace)

        {

            int oopsend = INT_MAX;

            /* line needs to start with " [" or have "] [" if it is still a call trace */

            /* example: "[<ffffffffa006c156>] radeon_get_ring_head+0x16/0x41 [radeon]" */

            /* example s390: "([<ffffffffa006c156>] 0xdeadbeaf)" */

            if ((curline[0] != '[' && (curline[0] != '(' || curline[1] != '['))

             && !strstr(curline, "] [")

             && !strstr(curline, "--- Exception")

             && !strstr(curline, "LR =")

             && !strstr(curline, "<#DF>")

             && !strstr(curline, "<IRQ>")

             && !strstr(curline, "<EOI>")

             && !strstr(curline, "<NMI>")

             && !strstr(curline, "<<EOE>>")

             && !strstr(curline, "Comm:")

             && !strstr(curline, "Hardware name:")

             && !strstr(curline, "Backtrace:")

             && strncmp(curline, "Code: ", 6) != 0

             && strncmp(curline, "RIP ", 4) != 0

             && strncmp(curline, "RSP ", 4) != 0

             /* s390 Call Trace ends with 'Last Breaking-Event-Address:'

              * which is followed by a single frame */

             && strncmp(curline, "Last Breaking-Event-Address:", strlen("Last Breaking-Event-Address:")) != 0

             /* ARM dumps registers intertwined with the backtrace */

             && (arm_regex_rc == 0 ? regexec(&arm_regex, curline, 0, NULL, 0) == REG_NOMATCH : 1)

            ) {

                oopsend = i-1; /* not a call trace line */

            }

            /* oops lines are always more than 8 chars long */

            else if (strnlen(curline, 8) < 8)

                oopsend = i-1;

            /* single oopses are of the same loglevel */

            else if (lines_info[i].level != prevlevel)

                oopsend = i-1;

            else if (strstr(curline, "Instruction dump:"))

                oopsend = i;

            /* kernel end-of-oops marker (not including marker itself) */

            else if (strstr(curline, "---[ end trace"))

                oopsend = i-1;

            /* if a new oops starts, this one has ended */

            else if (suspicious_line(curline))

                oopsend = i-1;

            if (oopsend <= i)

            {

                log_debug("End of oops at line %d (%d): '%s'", oopsend, i, lines_info[oopsend].ptr);

                record_oops(oops_list, lines_info, oopsstart, oopsend);

                oopsstart = -1;

                inbacktrace = 0;

            }

        }

        prevlevel = lines_info[i].level;

        i++;

        if (oopsstart >= 0)

        {

            /* Do we have a suspiciously long oops? Cancel it.

             * Bumped from 60 to 80 (see examples/oops_recursive_locking1.test)

             */

            if (i - oopsstart > 80)

            {

                inbacktrace = 0;

                oopsstart = -1;

                log_debug("Dropped oops, too long");

                continue;

            }

            if (!inbacktrace && i - oopsstart > 40)

            {

                /* Used to drop oopses w/o backtraces, but some of them

                 * (MCEs, for example) don't have backtrace yet we still want to file them.

                 */

                log_debug("One-line oops at line %d: '%s'", oopsstart, lines_info[oopsstart].ptr);

                record_oops(oops_list, lines_info, oopsstart, oopsstart);

                /*inbacktrace = 0; - already is */

                oopsstart = -1;

                continue;

            }

        }

    } /* while (i < lines_info_size) */

    regfree(&arm_regex);

    /* process last oops if we have one */

    if (oopsstart >= 0)

    {

        if (inbacktrace)

        {

            int oopsend = i-1;

            log_debug("End of oops at line %d (end of file): '%s'", oopsend, lines_info[oopsend].ptr);

            record_oops(oops_list, lines_info, oopsstart, oopsend);

        }

        else

        {

            log_debug("One-line oops at line %d: '%s'", oopsstart, lines_info[oopsstart].ptr);

            record_oops(oops_list, lines_info, oopsstart, oopsstart);

        }

    }

}

int koops_hash_str_ext(char result[SHA1_RESULT_LEN*2 + 1], const char *oops_buf, int frame_count, int duphash_flags)

{

    char *hash_str = NULL, *error = NULL;

    int bad = 0;

    struct sr_stacktrace *stacktrace = sr_stacktrace_parse(SR_REPORT_KERNELOOPS,

                                                           oops_buf, &error);

    if (!stacktrace)

    {

        log_debug("Failed to parse koops: %s", error);

        free(error);

        bad = 1;

        goto end;

    }

    struct sr_thread *thread = sr_stacktrace_find_crash_thread(stacktrace);

    if (!thread)

    {

        log_debug("Failed to find crash thread");

        bad = 1;

        goto end;

    }

    if (g_verbose >= 3)

    {

        hash_str = sr_thread_get_duphash(thread, frame_count, NULL,

                                         duphash_flags|SR_DUPHASH_NOHASH);

        if (hash_str)

            log_warning("Generating duphash: '%s'", hash_str);

        else

            log_warning("Nothing useful for duphash");

        free(hash_str);

    }

    hash_str = sr_thread_get_duphash(thread, frame_count, NULL, duphash_flags);

    if (hash_str)

    {

        strncpy(result, hash_str, SHA1_RESULT_LEN*2);

        result[SHA1_RESULT_LEN*2] = '\0';

        free(hash_str);

    }

    else

        bad = 1;

end:

    sr_stacktrace_free(stacktrace);

    return bad;

}

int koops_hash_str(char result[SHA1_RESULT_LEN*2 + 1], const char *oops_buf)

{

    const int frame_count = 6;

    const int duphash_flags = SR_DUPHASH_NONORMALIZE|SR_DUPHASH_KOOPS_COMPAT;

    return koops_hash_str_ext(result, oops_buf, frame_count, duphash_flags);

}

char *koops_extract_version(const char *linepointer)

{

    if (strstr(linepointer, "Pid")

     || strstr(linepointer, "comm")

     || strstr(linepointer, "CPU")

     || strstr(linepointer, "REGS")

     || strstr(linepointer, "EFLAGS")

    ) {

        /* "(4.7.0-2.x86_64.fc25) #"    */

        /* " 4.7.0-2.x86_64.fc25 #"     */

        /* " 2.6.3.4.5-2.x86_64.fc22 #" */

        const char *regexp = "([ \\(]|kernel-)([0-9]+\\.[0-9]+\\.[0-9]+(\\.[^.-]+)*-[^ \\)]+)\\)? #";

        regex_t re;

        int r = regcomp(&re, regexp, REG_EXTENDED);

        if (r != 0)

        {

            char buf[LINE_MAX];

            regerror(r, &re, buf, sizeof(buf));

            error_msg("BUG: invalid kernel version regexp: %s", buf);

            return NULL;

        }

        regmatch_t matchptr[3];

        r = regexec(&re, linepointer, sizeof(matchptr)/sizeof(matchptr[0]), matchptr, 0);

        if (r != 0)

        {

            if (r != REG_NOMATCH)

            {

                char buf[LINE_MAX];

                regerror(r, &re, buf, sizeof(buf));

                error_msg("BUG: kernel version regexp failed: %s", buf);

            }

            else

            {

                log_debug("A kernel version candidate line didn't match kernel oops regexp:");

                log_debug("\t'%s'", linepointer);

            }

            regfree(&re);

            return NULL;

        }

        /* 0: entire string */

        /* 1: version prefix */

        /* 2: version string */

        const regmatch_t *const ver = matchptr + 2;

        char *ret = xstrndup(linepointer + ver->rm_so, ver->rm_eo - ver->rm_so);

        regfree(&re);

        return ret;

    }

    return NULL;

}

/* reading /proc/sys/kernel/tainted file after an oops is ALWAYS going

 * to show it as tainted.

 *

 * https://bugzilla.redhat.com/show_bug.cgi?id=724838

 */

/**

 *	print_tainted - return a string to represent the kernel taint state.

 *

 *  'P' - Proprietary module has been loaded.

 *  'F' - Module has been forcibly loaded.

 *  'S' - SMP with CPUs not designed for SMP.

 *  'R' - User forced a module unload.

 *  'M' - System experienced a machine check exception.

 *  'B' - System has hit bad_page.

 *  'U' - Userspace-defined naughtiness.

 *  'D' - Kernel has oopsed before

 *  'A' - ACPI table overridden.

 *  'W' - Taint on warning.

 *  'C' - modules from drivers/staging are loaded.

 *  'I' - Working around severe firmware bug.

 *  'O' - Out-of-tree module has been loaded.

 *  'E' - Unsigned module has been loaded.

 *  'L' - A soft lockup has previously occurred.

 *  'K' - Kernel has been live patched.

 *

 * Compatibility flags from older versions and downstream sources:

 *  'H' - Hardware is unsupported.

 *  'T' - Tech_preview

 */

#if 0 /* unused */

static char *turn_off_flag(char *flags, char flag)

{

    size_t len = strlen(flags);

    for (int i = 0; i < len; ++i)

    {

        if (flags[i] == flag)

            flags[i] = ' ';

    }

    return flags;

}

#endif

char *kernel_tainted_short(const char *kernel_bt)

{

    /* example of flags: 'Tainted: G    B       ' */

    char *tainted = strstr(kernel_bt, "Tainted: ");

    if (!tainted)

        return NULL;

    tainted += strlen("Tainted: ");

    /* 17 + 2 == current count of known flags */

    /* http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=blob_plain;f=kernel/panic.c;hb=HEAD */

    /* 26 the maximal sane count of flags because of alphabet limits */

    unsigned sz = 26 + 1;

    unsigned cnt = 0;

    char *tnt = xmalloc(sz);

    for (;;)

    {

        if (tainted[0] >= 'A' && tainted[0] <= 'Z')

        {

            if (cnt == sz - 1)

            {   /* this should not happen but */

                /* I guess, it's a bit better approach than simple failure */

                sz <<= 1;

                tnt = xrealloc(tnt, sizeof(char) * sz);

            }

            tnt[cnt] = tainted[0];

            ++cnt;

        }

        else if (tainted[0] != ' ')

            break;

        ++tainted;

    }

    if (cnt == 0)

    {   /* this should not happen

         * cnt eq 0 means that a tainted string contains only spaces */

        free(tnt);

        return NULL;

    }

    tnt[cnt] = '\0';

    return tnt;

}

static const char *const tnts_long[] = {

    /* A */ "ACPI table overridden.",

    /* B */ "System has hit bad_page.",

    /* C */ "Modules from drivers/staging are loaded.",

    /* D */ "Kernel has oopsed before",

    /* E */ "Unsigned module has been loaded.",

    /* F */ "Module has been forcibly loaded.",

            /* We don't want to be more descriptive about G flag */

    /* G */ NULL, /* "Proprietary module has not been loaded." */

    /* H */ NULL,

    /* I */ "Working around severe firmware bug.",

    /* J */ NULL,

    /* K */ "Kernel has been live patched.",

    /* L */ "A soft lockup has previously occurred.",

    /* M */ "System experienced a machine check exception.",

    /* N */ NULL,

    /* O */ "Out-of-tree module has been loaded.",

    /* P */ "Proprietary module has been loaded.",

    /* Q */ NULL,

    /* R */ "User forced a module unload.",

    /* S */ "SMP with CPUs not designed for SMP.",

    /* T */ NULL,

    /* U */ "Userspace-defined naughtiness.",

    /* V */ NULL,

    /* W */ "Taint on warning.",

    /* X */ NULL,

    /* Y */ NULL,

    /* Z */ NULL,

};

char *kernel_tainted_long(const char *tainted_short)

{

    struct strbuf *tnt_long = strbuf_new();

    while (tainted_short[0] != '\0')

    {

        const int tnt_index = tainted_short[0] - 'A';

        if (tnt_index >= 0 && tnt_index <= 'Z' - 'A')

        {

            const char *const txt = tnts_long[tnt_index];

            if (txt)

                strbuf_append_strf(tnt_long, "%c - %s\n", tainted_short[0], txt);

        }

        ++tainted_short;

    }

    return strbuf_free_nobuf(tnt_long);

}