7: 'U' if a user or user application specifically requested that the
      Tainted flag be set, ' ' otherwise.
 
+  8: 'D' if the kernel has died recently, i.e. there was an OOPS or BUG.
+
 The primary reason for the 'Tainted: ' string is to tell kernel
 debuggers if this is a clean kernel or if anything unusual has
 occurred.  Tainting is permanent: even if an offending module is
 
 #endif
        printk("%s(%d): %s %ld\n", current->comm, current->pid, str, err);
        dik_show_regs(regs, r9_15);
+       add_taint(TAINT_DIE);
        dik_show_trace((unsigned long *)(regs+1));
        dik_show_code((unsigned int *)regs->pc);
 
 
        bust_spinlocks(1);
        __die(str, err, thread, regs);
        bust_spinlocks(0);
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
 
        if (in_interrupt())
 
        printk("Internal error: %s: %x\n", str, err);
        printk("CPU: %d\n", smp_processor_id());
        show_regs(regs);
+       add_taint(TAINT_DIE);
        printk("Process %s (pid: %d, stack limit = 0x%p)\n",
                current->comm, current->pid, end_of_stack(tsk));
 
 
        show_regs_log_lvl(regs, KERN_EMERG);
        show_stack_log_lvl(current, regs->sp, regs, KERN_EMERG);
        bust_spinlocks(0);
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
 
        if (in_interrupt())
 
 
        bust_spinlocks(0);
        die.lock_owner = -1;
+       add_taint(TAINT_DIE);
        spin_unlock_irqrestore(&die.lock, flags);
 
        if (!regs)
 
 
        bust_spinlocks(0);
        die.lock_owner = -1;
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die.lock);
 
        if (panic_on_oops)
 
        console_verbose();
        printk("%s: %08x\n",str,nr);
        show_registers(fp);
+       add_taint(TAINT_DIE);
        do_exit(SIGSEGV);
 }
 
 
        printk(KERN_EMERG "Process %s (pid: %d, stackpage=%08lx)\n",
                current->comm, current->pid, PAGE_SIZE+(unsigned long)current);
        show_stack(NULL, (unsigned long *)fp);
+       add_taint(TAINT_DIE);
        do_exit(SIGSEGV);
 }
 
 
 #endif /* CONFIG_MIPS_MT_SMTC */
        printk("%s[#%d]:\n", str, ++die_counter);
        show_registers(regs);
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
 
        if (in_interrupt())
 
 
        show_regs(regs);
        dump_stack();
+       add_taint(TAINT_DIE);
 
        if (in_interrupt())
                panic("Fatal exception in interrupt");
 
 
        bust_spinlocks(0);
        die.lock_owner = -1;
+       add_taint(TAINT_DIE);
        spin_unlock_irqrestore(&die.lock, flags);
 
        if (kexec_should_crash(current) ||
 
        if (nl)
                printk("\n");
        show_regs(fp);
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
        /* do_exit() should take care of panic'ing from an interrupt
         * context so we don't handle it here
 
        print_modules();
        show_regs(regs);
        bust_spinlocks(0);
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
        if (in_interrupt())
                panic("Fatal exception in interrupt");
 
                         (unsigned long)task_stack_page(current));
 
        bust_spinlocks(0);
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
 
        if (kexec_should_crash(current))
 
 
        printk("%s(%d): %s [#%d]\n", current->comm, current->pid, str, ++die_counter);
        show_regs(regs);
+       add_taint(TAINT_DIE);
 
        __SAVE; __SAVE; __SAVE; __SAVE;
        __SAVE; __SAVE; __SAVE; __SAVE;
 
        notify_die(DIE_OOPS, str, regs, 0, 255, SIGSEGV);
        __asm__ __volatile__("flushw");
        __show_regs(regs);
+       add_taint(TAINT_DIE);
        if (regs->tstate & TSTATE_PRIV) {
                struct reg_window *rw = (struct reg_window *)
                        (regs->u_regs[UREG_FP] + STACK_BIAS);
 
        printk("\n");
        notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
        show_registers(regs);
+       add_taint(TAINT_DIE);
        /* Executive summary in case the oops scrolled away */
        printk(KERN_ALERT "RIP ");
        printk_address(regs->rip); 
 
        if (!user_mode(regs))
                show_stack(NULL, (unsigned long*)regs->areg[1]);
 
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
 
        if (in_interrupt())
 
 #define TAINT_MACHINE_CHECK            (1<<4)
 #define TAINT_BAD_PAGE                 (1<<5)
 #define TAINT_USER                     (1<<6)
+#define TAINT_DIE                      (1<<7)
 
 extern void dump_stack(void);
 
 
 {
        static char buf[20];
        if (tainted) {
-               snprintf(buf, sizeof(buf), "Tainted: %c%c%c%c%c%c%c",
+               snprintf(buf, sizeof(buf), "Tainted: %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_USER ? 'U' : ' ',
+                       tainted & TAINT_DIE ? 'D' : ' ');
        }
        else
                snprintf(buf, sizeof(buf), "Not tainted");