2011-09-30 21:06:19 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
* Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
|
2011-09-30 21:06:21 +02:00
|
|
|
* Copyright (C) 2011 Don Zickus Red Hat, Inc.
|
2011-09-30 21:06:19 +02:00
|
|
|
*
|
|
|
|
* Pentium III FXSR, SSE support
|
|
|
|
* Gareth Hughes <gareth@valinux.com>, May 2000
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle hardware traps and faults.
|
|
|
|
*/
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/kdebug.h>
|
|
|
|
#include <linux/nmi.h>
|
2013-06-21 17:51:35 +02:00
|
|
|
#include <linux/debugfs.h>
|
2011-09-30 21:06:20 +02:00
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/hardirq.h>
|
|
|
|
#include <linux/slab.h>
|
2011-05-26 18:22:53 +02:00
|
|
|
#include <linux/export.h>
|
2011-09-30 21:06:19 +02:00
|
|
|
|
|
|
|
#if defined(CONFIG_EDAC)
|
|
|
|
#include <linux/edac.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <linux/atomic.h>
|
|
|
|
#include <asm/traps.h>
|
|
|
|
#include <asm/mach_traps.h>
|
2011-09-30 21:06:20 +02:00
|
|
|
#include <asm/nmi.h>
|
2011-11-10 14:45:24 +01:00
|
|
|
#include <asm/x86_init.h>
|
2011-09-30 21:06:20 +02:00
|
|
|
|
2013-06-21 17:51:38 +02:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/nmi.h>
|
|
|
|
|
2011-09-30 21:06:20 +02:00
|
|
|
struct nmi_desc {
|
|
|
|
spinlock_t lock;
|
|
|
|
struct list_head head;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct nmi_desc nmi_desc[NMI_MAX] =
|
|
|
|
{
|
|
|
|
{
|
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(&nmi_desc[0].lock),
|
|
|
|
.head = LIST_HEAD_INIT(nmi_desc[0].head),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(&nmi_desc[1].lock),
|
|
|
|
.head = LIST_HEAD_INIT(nmi_desc[1].head),
|
|
|
|
},
|
2012-03-29 22:11:16 +02:00
|
|
|
{
|
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(&nmi_desc[2].lock),
|
|
|
|
.head = LIST_HEAD_INIT(nmi_desc[2].head),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(&nmi_desc[3].lock),
|
|
|
|
.head = LIST_HEAD_INIT(nmi_desc[3].head),
|
|
|
|
},
|
2011-09-30 21:06:20 +02:00
|
|
|
|
|
|
|
};
|
2011-09-30 21:06:19 +02:00
|
|
|
|
2011-09-30 21:06:23 +02:00
|
|
|
struct nmi_stats {
|
|
|
|
unsigned int normal;
|
|
|
|
unsigned int unknown;
|
|
|
|
unsigned int external;
|
|
|
|
unsigned int swallow;
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_PER_CPU(struct nmi_stats, nmi_stats);
|
|
|
|
|
2011-09-30 21:06:19 +02:00
|
|
|
static int ignore_nmis;
|
|
|
|
|
|
|
|
int unknown_nmi_panic;
|
|
|
|
/*
|
|
|
|
* Prevent NMI reason port (0x61) being accessed simultaneously, can
|
|
|
|
* only be used in NMI handler.
|
|
|
|
*/
|
|
|
|
static DEFINE_RAW_SPINLOCK(nmi_reason_lock);
|
|
|
|
|
|
|
|
static int __init setup_unknown_nmi_panic(char *str)
|
|
|
|
{
|
|
|
|
unknown_nmi_panic = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("unknown_nmi_panic", setup_unknown_nmi_panic);
|
|
|
|
|
2011-09-30 21:06:20 +02:00
|
|
|
#define nmi_to_desc(type) (&nmi_desc[type])
|
|
|
|
|
2013-06-21 17:51:35 +02:00
|
|
|
static u64 nmi_longest_ns = 1 * NSEC_PER_MSEC;
|
2014-02-03 18:02:09 +01:00
|
|
|
|
2013-06-21 17:51:35 +02:00
|
|
|
static int __init nmi_warning_debugfs(void)
|
|
|
|
{
|
|
|
|
debugfs_create_u64("nmi_longest_ns", 0644,
|
|
|
|
arch_debugfs_dir, &nmi_longest_ns);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
fs_initcall(nmi_warning_debugfs);
|
|
|
|
|
2014-02-03 18:02:09 +01:00
|
|
|
static void nmi_max_handler(struct irq_work *w)
|
|
|
|
{
|
|
|
|
struct nmiaction *a = container_of(w, struct nmiaction, irq_work);
|
|
|
|
int remainder_ns, decimal_msecs;
|
|
|
|
u64 whole_msecs = ACCESS_ONCE(a->max_duration);
|
|
|
|
|
|
|
|
remainder_ns = do_div(whole_msecs, (1000 * 1000));
|
|
|
|
decimal_msecs = remainder_ns / 1000;
|
|
|
|
|
|
|
|
printk_ratelimited(KERN_INFO
|
|
|
|
"INFO: NMI handler (%ps) took too long to run: %lld.%03d msecs\n",
|
|
|
|
a->handler, whole_msecs, decimal_msecs);
|
|
|
|
}
|
|
|
|
|
2014-04-17 10:18:14 +02:00
|
|
|
static int nmi_handle(unsigned int type, struct pt_regs *regs, bool b2b)
|
2011-09-30 21:06:20 +02:00
|
|
|
{
|
|
|
|
struct nmi_desc *desc = nmi_to_desc(type);
|
|
|
|
struct nmiaction *a;
|
|
|
|
int handled=0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* NMIs are edge-triggered, which means if you have enough
|
|
|
|
* of them concurrently, you can lose some because only one
|
|
|
|
* can be latched at any given time. Walk the whole list
|
|
|
|
* to handle those situations.
|
|
|
|
*/
|
2013-06-21 17:51:35 +02:00
|
|
|
list_for_each_entry_rcu(a, &desc->head, list) {
|
2014-02-03 18:02:09 +01:00
|
|
|
int thishandled;
|
|
|
|
u64 delta;
|
2013-06-21 17:51:35 +02:00
|
|
|
|
2014-02-03 18:02:09 +01:00
|
|
|
delta = sched_clock();
|
2013-06-21 17:51:38 +02:00
|
|
|
thishandled = a->handler(type, regs);
|
|
|
|
handled += thishandled;
|
2014-02-03 18:02:09 +01:00
|
|
|
delta = sched_clock() - delta;
|
2013-06-21 17:51:38 +02:00
|
|
|
trace_nmi_handler(a->handler, (int)delta, thishandled);
|
2013-06-21 17:51:35 +02:00
|
|
|
|
2014-02-03 18:02:09 +01:00
|
|
|
if (delta < nmi_longest_ns || delta < a->max_duration)
|
2013-06-21 17:51:35 +02:00
|
|
|
continue;
|
|
|
|
|
2014-02-03 18:02:09 +01:00
|
|
|
a->max_duration = delta;
|
|
|
|
irq_work_queue(&a->irq_work);
|
2013-06-21 17:51:35 +02:00
|
|
|
}
|
2011-09-30 21:06:20 +02:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
/* return total number of NMI events handled */
|
|
|
|
return handled;
|
|
|
|
}
|
2014-04-17 10:18:14 +02:00
|
|
|
NOKPROBE_SYMBOL(nmi_handle);
|
2011-09-30 21:06:20 +02:00
|
|
|
|
2012-03-29 22:11:17 +02:00
|
|
|
int __register_nmi_handler(unsigned int type, struct nmiaction *action)
|
2011-09-30 21:06:20 +02:00
|
|
|
{
|
|
|
|
struct nmi_desc *desc = nmi_to_desc(type);
|
|
|
|
unsigned long flags;
|
|
|
|
|
2012-03-29 22:11:17 +02:00
|
|
|
if (!action->handler)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-02-03 18:02:09 +01:00
|
|
|
init_irq_work(&action->irq_work, nmi_max_handler);
|
|
|
|
|
2011-09-30 21:06:20 +02:00
|
|
|
spin_lock_irqsave(&desc->lock, flags);
|
|
|
|
|
2011-09-30 21:06:22 +02:00
|
|
|
/*
|
|
|
|
* most handlers of type NMI_UNKNOWN never return because
|
|
|
|
* they just assume the NMI is theirs. Just a sanity check
|
|
|
|
* to manage expectations
|
|
|
|
*/
|
|
|
|
WARN_ON_ONCE(type == NMI_UNKNOWN && !list_empty(&desc->head));
|
2012-03-29 22:11:16 +02:00
|
|
|
WARN_ON_ONCE(type == NMI_SERR && !list_empty(&desc->head));
|
|
|
|
WARN_ON_ONCE(type == NMI_IO_CHECK && !list_empty(&desc->head));
|
2011-09-30 21:06:22 +02:00
|
|
|
|
2011-09-30 21:06:20 +02:00
|
|
|
/*
|
|
|
|
* some handlers need to be executed first otherwise a fake
|
|
|
|
* event confuses some handlers (kdump uses this flag)
|
|
|
|
*/
|
|
|
|
if (action->flags & NMI_FLAG_FIRST)
|
|
|
|
list_add_rcu(&action->list, &desc->head);
|
|
|
|
else
|
|
|
|
list_add_tail_rcu(&action->list, &desc->head);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
return 0;
|
|
|
|
}
|
2012-03-29 22:11:17 +02:00
|
|
|
EXPORT_SYMBOL(__register_nmi_handler);
|
2011-09-30 21:06:20 +02:00
|
|
|
|
2012-03-29 22:11:17 +02:00
|
|
|
void unregister_nmi_handler(unsigned int type, const char *name)
|
2011-09-30 21:06:20 +02:00
|
|
|
{
|
|
|
|
struct nmi_desc *desc = nmi_to_desc(type);
|
|
|
|
struct nmiaction *n;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&desc->lock, flags);
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(n, &desc->head, list) {
|
|
|
|
/*
|
|
|
|
* the name passed in to describe the nmi handler
|
|
|
|
* is used as the lookup key
|
|
|
|
*/
|
|
|
|
if (!strcmp(n->name, name)) {
|
|
|
|
WARN(in_nmi(),
|
|
|
|
"Trying to free NMI (%s) from NMI context!\n", n->name);
|
|
|
|
list_del_rcu(&n->list);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
synchronize_rcu();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(unregister_nmi_handler);
|
|
|
|
|
2014-04-17 10:18:14 +02:00
|
|
|
static void
|
2011-09-30 21:06:19 +02:00
|
|
|
pci_serr_error(unsigned char reason, struct pt_regs *regs)
|
|
|
|
{
|
2012-03-29 22:11:16 +02:00
|
|
|
/* check to see if anyone registered against these types of errors */
|
|
|
|
if (nmi_handle(NMI_SERR, regs, false))
|
|
|
|
return;
|
|
|
|
|
2011-09-30 21:06:19 +02:00
|
|
|
pr_emerg("NMI: PCI system error (SERR) for reason %02x on CPU %d.\n",
|
|
|
|
reason, smp_processor_id());
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On some machines, PCI SERR line is used to report memory
|
|
|
|
* errors. EDAC makes use of it.
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_EDAC)
|
|
|
|
if (edac_handler_set()) {
|
|
|
|
edac_atomic_assert_error();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (panic_on_unrecovered_nmi)
|
|
|
|
panic("NMI: Not continuing");
|
|
|
|
|
|
|
|
pr_emerg("Dazed and confused, but trying to continue\n");
|
|
|
|
|
|
|
|
/* Clear and disable the PCI SERR error line. */
|
|
|
|
reason = (reason & NMI_REASON_CLEAR_MASK) | NMI_REASON_CLEAR_SERR;
|
|
|
|
outb(reason, NMI_REASON_PORT);
|
|
|
|
}
|
2014-04-17 10:18:14 +02:00
|
|
|
NOKPROBE_SYMBOL(pci_serr_error);
|
2011-09-30 21:06:19 +02:00
|
|
|
|
2014-04-17 10:18:14 +02:00
|
|
|
static void
|
2011-09-30 21:06:19 +02:00
|
|
|
io_check_error(unsigned char reason, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
|
2012-03-29 22:11:16 +02:00
|
|
|
/* check to see if anyone registered against these types of errors */
|
|
|
|
if (nmi_handle(NMI_IO_CHECK, regs, false))
|
|
|
|
return;
|
|
|
|
|
2011-09-30 21:06:19 +02:00
|
|
|
pr_emerg(
|
|
|
|
"NMI: IOCK error (debug interrupt?) for reason %02x on CPU %d.\n",
|
|
|
|
reason, smp_processor_id());
|
2012-05-09 09:47:37 +02:00
|
|
|
show_regs(regs);
|
2011-09-30 21:06:19 +02:00
|
|
|
|
|
|
|
if (panic_on_io_nmi)
|
|
|
|
panic("NMI IOCK error: Not continuing");
|
|
|
|
|
|
|
|
/* Re-enable the IOCK line, wait for a few seconds */
|
|
|
|
reason = (reason & NMI_REASON_CLEAR_MASK) | NMI_REASON_CLEAR_IOCHK;
|
|
|
|
outb(reason, NMI_REASON_PORT);
|
|
|
|
|
|
|
|
i = 20000;
|
|
|
|
while (--i) {
|
|
|
|
touch_nmi_watchdog();
|
|
|
|
udelay(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
reason &= ~NMI_REASON_CLEAR_IOCHK;
|
|
|
|
outb(reason, NMI_REASON_PORT);
|
|
|
|
}
|
2014-04-17 10:18:14 +02:00
|
|
|
NOKPROBE_SYMBOL(io_check_error);
|
2011-09-30 21:06:19 +02:00
|
|
|
|
2014-04-17 10:18:14 +02:00
|
|
|
static void
|
2011-09-30 21:06:19 +02:00
|
|
|
unknown_nmi_error(unsigned char reason, struct pt_regs *regs)
|
|
|
|
{
|
2011-09-30 21:06:21 +02:00
|
|
|
int handled;
|
|
|
|
|
2011-09-30 21:06:22 +02:00
|
|
|
/*
|
|
|
|
* Use 'false' as back-to-back NMIs are dealt with one level up.
|
|
|
|
* Of course this makes having multiple 'unknown' handlers useless
|
|
|
|
* as only the first one is ever run (unless it can actually determine
|
|
|
|
* if it caused the NMI)
|
|
|
|
*/
|
|
|
|
handled = nmi_handle(NMI_UNKNOWN, regs, false);
|
2011-09-30 21:06:23 +02:00
|
|
|
if (handled) {
|
|
|
|
__this_cpu_add(nmi_stats.unknown, handled);
|
2011-09-30 21:06:19 +02:00
|
|
|
return;
|
2011-09-30 21:06:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
__this_cpu_add(nmi_stats.unknown, 1);
|
|
|
|
|
2011-09-30 21:06:19 +02:00
|
|
|
pr_emerg("Uhhuh. NMI received for unknown reason %02x on CPU %d.\n",
|
|
|
|
reason, smp_processor_id());
|
|
|
|
|
|
|
|
pr_emerg("Do you have a strange power saving mode enabled?\n");
|
|
|
|
if (unknown_nmi_panic || panic_on_unrecovered_nmi)
|
|
|
|
panic("NMI: Not continuing");
|
|
|
|
|
|
|
|
pr_emerg("Dazed and confused, but trying to continue\n");
|
|
|
|
}
|
2014-04-17 10:18:14 +02:00
|
|
|
NOKPROBE_SYMBOL(unknown_nmi_error);
|
2011-09-30 21:06:19 +02:00
|
|
|
|
2011-09-30 21:06:22 +02:00
|
|
|
static DEFINE_PER_CPU(bool, swallow_nmi);
|
|
|
|
static DEFINE_PER_CPU(unsigned long, last_nmi_rip);
|
|
|
|
|
2014-04-17 10:18:14 +02:00
|
|
|
static void default_do_nmi(struct pt_regs *regs)
|
2011-09-30 21:06:19 +02:00
|
|
|
{
|
|
|
|
unsigned char reason = 0;
|
2011-09-30 21:06:21 +02:00
|
|
|
int handled;
|
2011-09-30 21:06:22 +02:00
|
|
|
bool b2b = false;
|
2011-09-30 21:06:19 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* CPU-specific NMI must be processed before non-CPU-specific
|
|
|
|
* NMI, otherwise we may lose it, because the CPU-specific
|
|
|
|
* NMI can not be detected/processed on other CPUs.
|
|
|
|
*/
|
2011-09-30 21:06:22 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Back-to-back NMIs are interesting because they can either
|
|
|
|
* be two NMI or more than two NMIs (any thing over two is dropped
|
|
|
|
* due to NMI being edge-triggered). If this is the second half
|
|
|
|
* of the back-to-back NMI, assume we dropped things and process
|
|
|
|
* more handlers. Otherwise reset the 'swallow' NMI behaviour
|
|
|
|
*/
|
|
|
|
if (regs->ip == __this_cpu_read(last_nmi_rip))
|
|
|
|
b2b = true;
|
|
|
|
else
|
|
|
|
__this_cpu_write(swallow_nmi, false);
|
|
|
|
|
|
|
|
__this_cpu_write(last_nmi_rip, regs->ip);
|
|
|
|
|
|
|
|
handled = nmi_handle(NMI_LOCAL, regs, b2b);
|
2011-09-30 21:06:23 +02:00
|
|
|
__this_cpu_add(nmi_stats.normal, handled);
|
2011-09-30 21:06:22 +02:00
|
|
|
if (handled) {
|
|
|
|
/*
|
|
|
|
* There are cases when a NMI handler handles multiple
|
|
|
|
* events in the current NMI. One of these events may
|
|
|
|
* be queued for in the next NMI. Because the event is
|
|
|
|
* already handled, the next NMI will result in an unknown
|
|
|
|
* NMI. Instead lets flag this for a potential NMI to
|
|
|
|
* swallow.
|
|
|
|
*/
|
|
|
|
if (handled > 1)
|
|
|
|
__this_cpu_write(swallow_nmi, true);
|
2011-09-30 21:06:19 +02:00
|
|
|
return;
|
2011-09-30 21:06:22 +02:00
|
|
|
}
|
2011-09-30 21:06:19 +02:00
|
|
|
|
|
|
|
/* Non-CPU-specific NMI: NMI sources can be processed on any CPU */
|
|
|
|
raw_spin_lock(&nmi_reason_lock);
|
2011-11-10 14:43:05 +01:00
|
|
|
reason = x86_platform.get_nmi_reason();
|
2011-09-30 21:06:19 +02:00
|
|
|
|
|
|
|
if (reason & NMI_REASON_MASK) {
|
|
|
|
if (reason & NMI_REASON_SERR)
|
|
|
|
pci_serr_error(reason, regs);
|
|
|
|
else if (reason & NMI_REASON_IOCHK)
|
|
|
|
io_check_error(reason, regs);
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
/*
|
|
|
|
* Reassert NMI in case it became active
|
|
|
|
* meanwhile as it's edge-triggered:
|
|
|
|
*/
|
|
|
|
reassert_nmi();
|
|
|
|
#endif
|
2011-09-30 21:06:23 +02:00
|
|
|
__this_cpu_add(nmi_stats.external, 1);
|
2011-09-30 21:06:19 +02:00
|
|
|
raw_spin_unlock(&nmi_reason_lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
raw_spin_unlock(&nmi_reason_lock);
|
|
|
|
|
2011-09-30 21:06:22 +02:00
|
|
|
/*
|
|
|
|
* Only one NMI can be latched at a time. To handle
|
|
|
|
* this we may process multiple nmi handlers at once to
|
|
|
|
* cover the case where an NMI is dropped. The downside
|
|
|
|
* to this approach is we may process an NMI prematurely,
|
|
|
|
* while its real NMI is sitting latched. This will cause
|
|
|
|
* an unknown NMI on the next run of the NMI processing.
|
|
|
|
*
|
|
|
|
* We tried to flag that condition above, by setting the
|
|
|
|
* swallow_nmi flag when we process more than one event.
|
|
|
|
* This condition is also only present on the second half
|
|
|
|
* of a back-to-back NMI, so we flag that condition too.
|
|
|
|
*
|
|
|
|
* If both are true, we assume we already processed this
|
|
|
|
* NMI previously and we swallow it. Otherwise we reset
|
|
|
|
* the logic.
|
|
|
|
*
|
|
|
|
* There are scenarios where we may accidentally swallow
|
|
|
|
* a 'real' unknown NMI. For example, while processing
|
|
|
|
* a perf NMI another perf NMI comes in along with a
|
|
|
|
* 'real' unknown NMI. These two NMIs get combined into
|
|
|
|
* one (as descibed above). When the next NMI gets
|
|
|
|
* processed, it will be flagged by perf as handled, but
|
|
|
|
* noone will know that there was a 'real' unknown NMI sent
|
|
|
|
* also. As a result it gets swallowed. Or if the first
|
|
|
|
* perf NMI returns two events handled then the second
|
|
|
|
* NMI will get eaten by the logic below, again losing a
|
|
|
|
* 'real' unknown NMI. But this is the best we can do
|
|
|
|
* for now.
|
|
|
|
*/
|
|
|
|
if (b2b && __this_cpu_read(swallow_nmi))
|
2011-09-30 21:06:23 +02:00
|
|
|
__this_cpu_add(nmi_stats.swallow, 1);
|
2011-09-30 21:06:22 +02:00
|
|
|
else
|
|
|
|
unknown_nmi_error(reason, regs);
|
2011-09-30 21:06:19 +02:00
|
|
|
}
|
2014-04-17 10:18:14 +02:00
|
|
|
NOKPROBE_SYMBOL(default_do_nmi);
|
2011-09-30 21:06:19 +02:00
|
|
|
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
/*
|
|
|
|
* NMIs can hit breakpoints which will cause it to lose its
|
|
|
|
* NMI context with the CPU when the breakpoint does an iret.
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
/*
|
|
|
|
* For i386, NMIs use the same stack as the kernel, and we can
|
2012-06-07 17:03:00 +02:00
|
|
|
* add a workaround to the iret problem in C (preventing nested
|
|
|
|
* NMIs if an NMI takes a trap). Simply have 3 states the NMI
|
|
|
|
* can be in:
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
*
|
|
|
|
* 1) not running
|
|
|
|
* 2) executing
|
|
|
|
* 3) latched
|
|
|
|
*
|
|
|
|
* When no NMI is in progress, it is in the "not running" state.
|
|
|
|
* When an NMI comes in, it goes into the "executing" state.
|
|
|
|
* Normally, if another NMI is triggered, it does not interrupt
|
|
|
|
* the running NMI and the HW will simply latch it so that when
|
|
|
|
* the first NMI finishes, it will restart the second NMI.
|
|
|
|
* (Note, the latch is binary, thus multiple NMIs triggering,
|
|
|
|
* when one is running, are ignored. Only one NMI is restarted.)
|
|
|
|
*
|
|
|
|
* If an NMI hits a breakpoint that executes an iret, another
|
|
|
|
* NMI can preempt it. We do not want to allow this new NMI
|
|
|
|
* to run, but we want to execute it when the first one finishes.
|
2012-06-07 17:03:00 +02:00
|
|
|
* We set the state to "latched", and the exit of the first NMI will
|
|
|
|
* perform a dec_return, if the result is zero (NOT_RUNNING), then
|
|
|
|
* it will simply exit the NMI handler. If not, the dec_return
|
|
|
|
* would have set the state to NMI_EXECUTING (what we want it to
|
|
|
|
* be when we are running). In this case, we simply jump back
|
|
|
|
* to rerun the NMI handler again, and restart the 'latched' NMI.
|
|
|
|
*
|
|
|
|
* No trap (breakpoint or page fault) should be hit before nmi_restart,
|
|
|
|
* thus there is no race between the first check of state for NOT_RUNNING
|
|
|
|
* and setting it to NMI_EXECUTING. The HW will prevent nested NMIs
|
|
|
|
* at this point.
|
2012-06-07 17:54:37 +02:00
|
|
|
*
|
|
|
|
* In case the NMI takes a page fault, we need to save off the CR2
|
|
|
|
* because the NMI could have preempted another page fault and corrupt
|
|
|
|
* the CR2 that is about to be read. As nested NMIs must be restarted
|
|
|
|
* and they can not take breakpoints or page faults, the update of the
|
|
|
|
* CR2 must be done before converting the nmi state back to NOT_RUNNING.
|
|
|
|
* Otherwise, there would be a race of another nested NMI coming in
|
|
|
|
* after setting state to NOT_RUNNING but before updating the nmi_cr2.
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
*/
|
|
|
|
enum nmi_states {
|
2012-06-07 17:03:00 +02:00
|
|
|
NMI_NOT_RUNNING = 0,
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
NMI_EXECUTING,
|
|
|
|
NMI_LATCHED,
|
|
|
|
};
|
|
|
|
static DEFINE_PER_CPU(enum nmi_states, nmi_state);
|
2012-06-07 17:54:37 +02:00
|
|
|
static DEFINE_PER_CPU(unsigned long, nmi_cr2);
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
|
|
|
|
#define nmi_nesting_preprocess(regs) \
|
|
|
|
do { \
|
2012-06-07 17:03:00 +02:00
|
|
|
if (this_cpu_read(nmi_state) != NMI_NOT_RUNNING) { \
|
|
|
|
this_cpu_write(nmi_state, NMI_LATCHED); \
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
return; \
|
|
|
|
} \
|
2012-06-07 17:03:00 +02:00
|
|
|
this_cpu_write(nmi_state, NMI_EXECUTING); \
|
2012-06-07 17:54:37 +02:00
|
|
|
this_cpu_write(nmi_cr2, read_cr2()); \
|
2012-06-07 17:03:00 +02:00
|
|
|
} while (0); \
|
|
|
|
nmi_restart:
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
|
|
|
|
#define nmi_nesting_postprocess() \
|
|
|
|
do { \
|
2012-06-07 17:54:37 +02:00
|
|
|
if (unlikely(this_cpu_read(nmi_cr2) != read_cr2())) \
|
|
|
|
write_cr2(this_cpu_read(nmi_cr2)); \
|
2012-06-07 17:03:00 +02:00
|
|
|
if (this_cpu_dec_return(nmi_state)) \
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
goto nmi_restart; \
|
|
|
|
} while (0)
|
|
|
|
#else /* x86_64 */
|
|
|
|
/*
|
|
|
|
* In x86_64 things are a bit more difficult. This has the same problem
|
|
|
|
* where an NMI hitting a breakpoint that calls iret will remove the
|
|
|
|
* NMI context, allowing a nested NMI to enter. What makes this more
|
|
|
|
* difficult is that both NMIs and breakpoints have their own stack.
|
|
|
|
* When a new NMI or breakpoint is executed, the stack is set to a fixed
|
|
|
|
* point. If an NMI is nested, it will have its stack set at that same
|
|
|
|
* fixed address that the first NMI had, and will start corrupting the
|
|
|
|
* stack. This is handled in entry_64.S, but the same problem exists with
|
|
|
|
* the breakpoint stack.
|
|
|
|
*
|
|
|
|
* If a breakpoint is being processed, and the debug stack is being used,
|
|
|
|
* if an NMI comes in and also hits a breakpoint, the stack pointer
|
|
|
|
* will be set to the same fixed address as the breakpoint that was
|
|
|
|
* interrupted, causing that stack to be corrupted. To handle this case,
|
|
|
|
* check if the stack that was interrupted is the debug stack, and if
|
|
|
|
* so, change the IDT so that new breakpoints will use the current stack
|
|
|
|
* and not switch to the fixed address. On return of the NMI, switch back
|
|
|
|
* to the original IDT.
|
|
|
|
*/
|
|
|
|
static DEFINE_PER_CPU(int, update_debug_stack);
|
2011-12-09 09:02:19 +01:00
|
|
|
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
static inline void nmi_nesting_preprocess(struct pt_regs *regs)
|
|
|
|
{
|
2011-12-09 09:02:19 +01:00
|
|
|
/*
|
|
|
|
* If we interrupted a breakpoint, it is possible that
|
|
|
|
* the nmi handler will have breakpoints too. We need to
|
|
|
|
* change the IDT such that breakpoints that happen here
|
|
|
|
* continue to use the NMI stack.
|
|
|
|
*/
|
|
|
|
if (unlikely(is_debug_stack(regs->sp))) {
|
|
|
|
debug_stack_set_zero();
|
2012-05-30 17:43:19 +02:00
|
|
|
this_cpu_write(update_debug_stack, 1);
|
2011-12-09 09:02:19 +01:00
|
|
|
}
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void nmi_nesting_postprocess(void)
|
|
|
|
{
|
2012-05-30 17:43:19 +02:00
|
|
|
if (unlikely(this_cpu_read(update_debug_stack))) {
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
debug_stack_reset();
|
2012-05-30 17:43:19 +02:00
|
|
|
this_cpu_write(update_debug_stack, 0);
|
|
|
|
}
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-04-17 10:18:14 +02:00
|
|
|
dotraplinkage notrace void
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
do_nmi(struct pt_regs *regs, long error_code)
|
|
|
|
{
|
|
|
|
nmi_nesting_preprocess(regs);
|
|
|
|
|
2011-09-30 21:06:19 +02:00
|
|
|
nmi_enter();
|
|
|
|
|
|
|
|
inc_irq_stat(__nmi_count);
|
|
|
|
|
|
|
|
if (!ignore_nmis)
|
|
|
|
default_do_nmi(regs);
|
|
|
|
|
|
|
|
nmi_exit();
|
2011-12-09 09:02:19 +01:00
|
|
|
|
x86: Allow NMIs to hit breakpoints in i386
With i386, NMIs and breakpoints use the current stack and they
do not reset the stack pointer to a fix point that might corrupt
a previous NMI or breakpoint (as it does in x86_64). But NMIs are
still not made to be re-entrant, and need to prevent the case that
an NMI hitting a breakpoint (which does an iret), doesn't allow
another NMI to run.
The fix is to let the NMI be in 3 different states:
1) not running
2) executing
3) latched
When no NMI is executing on a given CPU, the state is "not running".
When the first NMI comes in, the state is switched to "executing".
On exit of that NMI, a cmpxchg is performed to switch the state
back to "not running" and if that fails, the NMI is restarted.
If a breakpoint is hit and does an iret, which re-enables NMIs,
and another NMI comes in before the first NMI finished, it will
detect that the state is not in the "not running" state and the
current NMI is nested. In this case, the state is switched to "latched"
to let the interrupted NMI know to restart the NMI handler, and
the nested NMI exits without doing anything.
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Paul Turner <pjt@google.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2011-12-13 22:44:16 +01:00
|
|
|
/* On i386, may loop back to preprocess */
|
|
|
|
nmi_nesting_postprocess();
|
2011-09-30 21:06:19 +02:00
|
|
|
}
|
2014-04-17 10:18:14 +02:00
|
|
|
NOKPROBE_SYMBOL(do_nmi);
|
2011-09-30 21:06:19 +02:00
|
|
|
|
|
|
|
void stop_nmi(void)
|
|
|
|
{
|
|
|
|
ignore_nmis++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void restart_nmi(void)
|
|
|
|
{
|
|
|
|
ignore_nmis--;
|
|
|
|
}
|
2011-09-30 21:06:22 +02:00
|
|
|
|
|
|
|
/* reset the back-to-back NMI logic */
|
|
|
|
void local_touch_nmi(void)
|
|
|
|
{
|
|
|
|
__this_cpu_write(last_nmi_rip, 0);
|
|
|
|
}
|
2013-01-04 12:12:44 +01:00
|
|
|
EXPORT_SYMBOL_GPL(local_touch_nmi);
|