4 files changed, 48 insertions, 49 deletions

diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index bc6ed52a39b9..441def77246d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -506,6 +506,15 @@ extern enum system_states {
 #define TAINT_UNSIGNED_MODULE           13
 #define TAINT_SOFTLOCKUP                14
 #define TAINT_LIVEPATCH                 15
+#define TAINT_FLAGS_COUNT               16
+
+struct taint_flag {
+        char true;      /* character printed when tainted */
+        char false;     /* character printed when not tainted */
+        bool module;    /* also show as a per-module taint flag */
+};
+
+extern const struct taint_flag taint_flags[TAINT_FLAGS_COUNT];
 
 extern const char hex_asc[];
 #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
diff --git a/include/linux/module.h b/include/linux/module.h
index 0c3207d26ac0..f6ee569c62bb 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -399,7 +399,7 @@ struct module {
         /* Arch-specific module values */
         struct mod_arch_specific arch;
 
-        unsigned int taints;    /* same bits as kernel:tainted */
+        unsigned long taints;   /* same bits as kernel:taint_flags */
 
 #ifdef CONFIG_GENERIC_BUG
         /* Support for BUG */
diff --git a/kernel/module.c b/kernel/module.c
index f57dd63186e6..a4acd8f403ae 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -330,7 +330,7 @@ static inline void add_taint_module(struct module *mod, unsigned flag,
                                     enum lockdep_ok lockdep_ok)
 {
         add_taint(flag, lockdep_ok);
-        mod->taints |= (1U << flag);
+        set_bit(flag, &mod->taints);
 }
 
 /*
@@ -1138,24 +1138,13 @@ static inline int module_unload_init(struct module *mod)
 static size_t module_flags_taint(struct module *mod, char *buf)
 {
         size_t l = 0;
+        int i;
+
+        for (i = 0; i < TAINT_FLAGS_COUNT; i++) {
+                if (taint_flags[i].module && test_bit(i, &mod->taints))
+                        buf[l++] = taint_flags[i].true;
+        }
 
-        if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
-                buf[l++] = 'P';
-        if (mod->taints & (1 << TAINT_OOT_MODULE))
-                buf[l++] = 'O';
-        if (mod->taints & (1 << TAINT_FORCED_MODULE))
-                buf[l++] = 'F';
-        if (mod->taints & (1 << TAINT_CRAP))
-                buf[l++] = 'C';
-        if (mod->taints & (1 << TAINT_UNSIGNED_MODULE))
-                buf[l++] = 'E';
-        if (mod->taints & (1 << TAINT_LIVEPATCH))
-                buf[l++] = 'K';
-        /*
-         * TAINT_FORCED_RMMOD: could be added.
-         * TAINT_CPU_OUT_OF_SPEC, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
-         * apply to modules.
-         */
         return l;
 }
 
@@ -4041,6 +4030,10 @@ int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
 }
 #endif /* CONFIG_KALLSYMS */
 
+/* Maximum number of characters written by module_flags() */
+#define MODULE_FLAGS_BUF_SIZE (TAINT_FLAGS_COUNT + 4)
+
+/* Keep in sync with MODULE_FLAGS_BUF_SIZE !!! */
 static char *module_flags(struct module *mod, char *buf)
 {
         int bx = 0;
@@ -4085,7 +4078,7 @@ static void m_stop(struct seq_file *m, void *p)
 static int m_show(struct seq_file *m, void *p)
 {
         struct module *mod = list_entry(p, struct module, list);
-        char buf[8];
+        char buf[MODULE_FLAGS_BUF_SIZE];
 
         /* We always ignore unformed modules. */
         if (mod->state == MODULE_STATE_UNFORMED)
@@ -4256,7 +4249,7 @@ EXPORT_SYMBOL_GPL(__module_text_address);
 void print_modules(void)
 {
         struct module *mod;
-        char buf[8];
+        char buf[MODULE_FLAGS_BUF_SIZE];
 
         printk(KERN_DEFAULT "Modules linked in:");
         /* Most callers should already have preempt disabled, but make sure */
diff --git a/kernel/panic.c b/kernel/panic.c
index e6480e20379e..c51edaa04fce 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -298,30 +298,27 @@ void panic(const char *fmt, ...)
 
 EXPORT_SYMBOL(panic);
 
-
-struct tnt {
-        u8      bit;
-        char    true;
-        char    false;
-};
-
-static const struct tnt tnts[] = {
-        { TAINT_PROPRIETARY_MODULE,     'P', 'G' },
-        { TAINT_FORCED_MODULE,          'F', ' ' },
-        { TAINT_CPU_OUT_OF_SPEC,        'S', ' ' },
-        { TAINT_FORCED_RMMOD,           'R', ' ' },
-        { TAINT_MACHINE_CHECK,          'M', ' ' },
-        { TAINT_BAD_PAGE,               'B', ' ' },
-        { TAINT_USER,                   'U', ' ' },
-        { TAINT_DIE,                    'D', ' ' },
-        { TAINT_OVERRIDDEN_ACPI_TABLE,  'A', ' ' },
-        { TAINT_WARN,                   'W', ' ' },
-        { TAINT_CRAP,                   'C', ' ' },
-        { TAINT_FIRMWARE_WORKAROUND,    'I', ' ' },
-        { TAINT_OOT_MODULE,             'O', ' ' },
-        { TAINT_UNSIGNED_MODULE,        'E', ' ' },
-        { TAINT_SOFTLOCKUP,             'L', ' ' },
-        { TAINT_LIVEPATCH,              'K', ' ' },
+/*
+ * TAINT_FORCED_RMMOD could be a per-module flag but the module
+ * is being removed anyway.
+ */
+const struct taint_flag taint_flags[TAINT_FLAGS_COUNT] = {
+        { 'P', 'G', true },     /* TAINT_PROPRIETARY_MODULE */
+        { 'F', ' ', true },     /* TAINT_FORCED_MODULE */
+        { 'S', ' ', false },    /* TAINT_CPU_OUT_OF_SPEC */
+        { 'R', ' ', false },    /* TAINT_FORCED_RMMOD */
+        { 'M', ' ', false },    /* TAINT_MACHINE_CHECK */
+        { 'B', ' ', false },    /* TAINT_BAD_PAGE */
+        { 'U', ' ', false },    /* TAINT_USER */
+        { 'D', ' ', false },    /* TAINT_DIE */
+        { 'A', ' ', false },    /* TAINT_OVERRIDDEN_ACPI_TABLE */
+        { 'W', ' ', false },    /* TAINT_WARN */
+        { 'C', ' ', true },     /* TAINT_CRAP */
+        { 'I', ' ', false },    /* TAINT_FIRMWARE_WORKAROUND */
+        { 'O', ' ', true },     /* TAINT_OOT_MODULE */
+        { 'E', ' ', true },     /* TAINT_UNSIGNED_MODULE */
+        { 'L', ' ', false },    /* TAINT_SOFTLOCKUP */
+        { 'K', ' ', true },     /* TAINT_LIVEPATCH */
 };
 
 /**
@@ -348,16 +345,16 @@ static const struct tnt tnts[] = {
  */
 const char *print_tainted(void)
 {
-        static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ")];
+        static char buf[TAINT_FLAGS_COUNT + sizeof("Tainted: ")];
 
         if (tainted_mask) {
                 char *s;
                 int i;
 
                 s = buf + sprintf(buf, "Tainted: ");
-                for (i = 0; i < ARRAY_SIZE(tnts); i++) {
-                        const struct tnt *t = &tnts[i];
-                        *s++ = test_bit(t->bit, &tainted_mask) ?
+                for (i = 0; i < TAINT_FLAGS_COUNT; i++) {
+                        const struct taint_flag *t = &taint_flags[i];
+                        *s++ = test_bit(i, &tainted_mask) ?
                                         t->true : t->false;
                 }
                 *s = 0;