4 files changed, 81 insertions, 63 deletions

diff --git a/kernel/module.c b/kernel/module.c
index 9db11911e04b..dd9ac6ad5cb9 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -100,7 +100,7 @@ static inline int strong_try_module_get(struct module *mod)
 static inline void add_taint_module(struct module *mod, unsigned flag)
 {
         add_taint(flag);
-        mod->taints |= flag;
+        mod->taints |= (1U << flag);
 }
 
 /*
@@ -923,7 +923,7 @@ static const char vermagic[] = VERMAGIC_STRING;
 static int try_to_force_load(struct module *mod, const char *symname)
 {
 #ifdef CONFIG_MODULE_FORCE_LOAD
-        if (!(tainted & TAINT_FORCED_MODULE))
+        if (!test_taint(TAINT_FORCED_MODULE))
                 printk("%s: no version for \"%s\" found: kernel tainted.\n",
                        mod->name, symname);
         add_taint_module(mod, TAINT_FORCED_MODULE);
@@ -1033,7 +1033,7 @@ static unsigned long resolve_symbol(Elf_Shdr *sechdrs,
         const unsigned long *crc;
 
         ret = find_symbol(name, &owner, &crc,
-                          !(mod->taints & TAINT_PROPRIETARY_MODULE), true);
+                          !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
         if (!IS_ERR_VALUE(ret)) {
                 /* use_module can fail due to OOM,
                    or module initialization or unloading */
@@ -1634,7 +1634,7 @@ static void set_license(struct module *mod, const char *license)
                 license = "unspecified";
 
         if (!license_is_gpl_compatible(license)) {
-                if (!(tainted & TAINT_PROPRIETARY_MODULE))
+                if (!test_taint(TAINT_PROPRIETARY_MODULE))
                         printk(KERN_WARNING "%s: module license '%s' taints "
                                 "kernel.\n", mod->name, license);
                 add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
@@ -2552,9 +2552,9 @@ static char *module_flags(struct module *mod, char *buf)
             mod->state == MODULE_STATE_GOING ||
             mod->state == MODULE_STATE_COMING) {
                 buf[bx++] = '(';
-                if (mod->taints & TAINT_PROPRIETARY_MODULE)
+                if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
                         buf[bx++] = 'P';
-                if (mod->taints & TAINT_FORCED_MODULE)
+                if (mod->taints & (1 << TAINT_FORCED_MODULE))
                         buf[bx++] = 'F';
                 /*
                  * TAINT_FORCED_RMMOD: could be added.
diff --git a/kernel/panic.c b/kernel/panic.c
index 12c5a0a6c89b..028013f7afd4 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -23,7 +23,7 @@
 #include <linux/kallsyms.h>
 
 int panic_on_oops;
-int tainted;
+static unsigned long tainted_mask;
 static int pause_on_oops;
 static int pause_on_oops_flag;
 static DEFINE_SPINLOCK(pause_on_oops_lock);
@@ -159,31 +159,60 @@ EXPORT_SYMBOL(panic);
  *      The string is overwritten by the next call to print_taint().
  */
 
+struct tnt {
+        u8 bit;
+        char true;
+        char false;
+};
+
+static const struct tnt tnts[] = {
+        { TAINT_PROPRIETARY_MODULE, 'P', 'G' },
+        { TAINT_FORCED_MODULE, 'F', ' ' },
+        { TAINT_UNSAFE_SMP, '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', ' ' },
+};
+
 const char *print_tainted(void)
 {
-        static char buf[20];
-        if (tainted) {
-                snprintf(buf, sizeof(buf), "Tainted: %c%c%c%c%c%c%c%c%c%c",
-                        tainted & TAINT_PROPRIETARY_MODULE ? 'P' : 'G',
-                        tainted & TAINT_FORCED_MODULE ? 'F' : ' ',
-                        tainted & TAINT_UNSAFE_SMP ? 'S' : ' ',
-                        tainted & TAINT_FORCED_RMMOD ? 'R' : ' ',
-                        tainted & TAINT_MACHINE_CHECK ? 'M' : ' ',
-                        tainted & TAINT_BAD_PAGE ? 'B' : ' ',
-                        tainted & TAINT_USER ? 'U' : ' ',
-                        tainted & TAINT_DIE ? 'D' : ' ',
-                        tainted & TAINT_OVERRIDDEN_ACPI_TABLE ? 'A' : ' ',
-                        tainted & TAINT_WARN ? 'W' : ' ');
-        }
-        else
+        static char buf[ARRAY_SIZE(tnts) + sizeof("Tainted: ") + 1];
+
+        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) ?
+                                        t->true : t->false;
+                }
+                *s = 0;
+        } else
                 snprintf(buf, sizeof(buf), "Not tainted");
         return(buf);
 }
 
+int test_taint(unsigned flag)
+{
+        return test_bit(flag, &tainted_mask);
+}
+EXPORT_SYMBOL(test_taint);
+
+unsigned long get_taint(void)
+{
+        return tainted_mask;
+}
+
 void add_taint(unsigned flag)
 {
         debug_locks = 0; /* can't trust the integrity of the kernel anymore */
-        tainted |= flag;
+        set_bit(flag, &tainted_mask);
 }
 EXPORT_SYMBOL(add_taint);
 
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index cb838ee93a82..3953e4aed733 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -226,7 +226,7 @@ static void check_hung_uninterruptible_tasks(int this_cpu)
          * If the system crashed already then all bets are off,
          * do not report extra hung tasks:
          */
-        if ((tainted & TAINT_DIE) || did_panic)
+        if (test_taint(TAINT_DIE) || did_panic)
                 return;
 
         read_lock(&tasklist_lock);
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index cfc5295f1e82..ec88fcc9a0d2 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -149,7 +149,7 @@ extern int max_lock_depth;
 #ifdef CONFIG_PROC_SYSCTL
 static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp,
                   void __user *buffer, size_t *lenp, loff_t *ppos);
-static int proc_dointvec_taint(struct ctl_table *table, int write, struct file *filp,
+static int proc_taint(struct ctl_table *table, int write, struct file *filp,
                                void __user *buffer, size_t *lenp, loff_t *ppos);
 #endif
 
@@ -379,10 +379,9 @@ static struct ctl_table kern_table[] = {
 #ifdef CONFIG_PROC_SYSCTL
         {
                 .procname       = "tainted",
-                .data           = &tainted,
-                .maxlen         = sizeof(int),
+                .maxlen         = sizeof(long),
                 .mode           = 0644,
-                .proc_handler   = &proc_dointvec_taint,
+                .proc_handler   = &proc_taint,
         },
 #endif
 #ifdef CONFIG_LATENCYTOP
@@ -2228,49 +2227,39 @@ int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
                             NULL,NULL);
 }
 
-#define OP_SET  0
-#define OP_AND  1
-#define OP_OR   2
-
-static int do_proc_dointvec_bset_conv(int *negp, unsigned long *lvalp,
-                                      int *valp,
-                                      int write, void *data)
-{
-        int op = *(int *)data;
-        if (write) {
-                int val = *negp ? -*lvalp : *lvalp;
-                switch(op) {
-                case OP_SET:    *valp = val; break;
-                case OP_AND:    *valp &= val; break;
-                case OP_OR:     *valp |= val; break;
-                }
-        } else {
-                int val = *valp;
-                if (val < 0) {
-                        *negp = -1;
-                        *lvalp = (unsigned long)-val;
-                } else {
-                        *negp = 0;
-                        *lvalp = (unsigned long)val;
-                }
-        }
-        return 0;
-}
-
 /*
- *      Taint values can only be increased
+ * Taint values can only be increased
+ * This means we can safely use a temporary.
  */
-static int proc_dointvec_taint(struct ctl_table *table, int write, struct file *filp,
+static int proc_taint(struct ctl_table *table, int write, struct file *filp,
                                void __user *buffer, size_t *lenp, loff_t *ppos)
 {
-        int op;
+        struct ctl_table t;
+        unsigned long tmptaint = get_taint();
+        int err;
 
         if (write && !capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        op = OP_OR;
-        return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
-                                do_proc_dointvec_bset_conv,&op);
+        t = *table;
+        t.data = &tmptaint;
+        err = proc_doulongvec_minmax(&t, write, filp, buffer, lenp, ppos);
+        if (err < 0)
+                return err;
+
+        if (write) {
+                /*
+                 * Poor man's atomic or. Not worth adding a primitive
+                 * to everyone's atomic.h for this
+                 */
+                int i;
+                for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
+                        if ((tmptaint >> i) & 1)
+                                add_taint(i);
+                }
+        }
+
+        return err;
 }
 
 struct do_proc_dointvec_minmax_conv_param {