QEMU, MCE, unpoison memory address across reboot

Huang Ying
2010-12-22T02:53:13Z

In Linux kernel HWPoison processing implementation, the virtual
address in processes mapping the error physical memory page is marked
as HWPoison. So that, the further accessing to the virtual
address will kill corresponding processes with SIGBUS.

If the error physical memory page is used by a KVM guest, the SIGBUS
will be sent to QEMU, and QEMU will simulate a MCE to report that
memory error to the guest OS. If the guest OS can not recover from
the error (for example, the page is accessed by kernel code), guest OS
will reboot the system. But because the underlying host virtual
address backing the guest physical memory is still poisoned, if the
guest system accesses the corresponding guest physical memory even
after rebooting, the SIGBUS will still be sent to QEMU and MCE will be
simulated. That is, guest system can not recover via rebooting.

In fact, across rebooting, the contents of guest physical memory page
need not to be kept. We can allocate a new host physical page to
back the corresponding guest physical address.

This patch fixes this issue in QEMU-KVM via invoke the unpoison
mechanism implemented in Linux kernel to clear the corresponding page
table entry, so that make it possible to allocate a new page to
recover the issue.

Signed-off-by: Huang Ying <ying.huang@intel.com>
---
kvm.h | 2 ++
kvm/include/linux/kvm.h | 2 ++
qemu-kvm.c | 40 ++++++++++++++++++++++++++++++++++++++++
target-i386/kvm.c | 2 ++
4 files changed, 46 insertions(+)

--- a/target-i386/kvm.c
+++ b/target-i386/kvm.c
@@ -1803,6 +1803,7 @@ int kvm_on_sigbus_vcpu(CPUState *env, in
hardware_memory_error();
}
}
+ kvm_hwpoison_page_add(vaddr);
mce.addr = paddr;
r = kvm_set_mce(env, &mce);
if (r < 0) {
@@ -1841,6 +1842,7 @@ int kvm_on_sigbus(int code, void *addr)
"QEMU itself instead of guest system!: %p\n", addr);
return 0;
}
+ kvm_hwpoison_page_add(vaddr);
status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN
| MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S
| 0xc0;
--- a/kvm/include/linux/kvm.h
+++ b/kvm/include/linux/kvm.h
@@ -663,6 +663,8 @@ struct kvm_clock_data {
/* Available with KVM_CAP_PIT_STATE2 */
#define KVM_GET_PIT2 _IOR(KVMIO, 0x9f, struct kvm_pit_state2)
#define KVM_SET_PIT2 _IOW(KVMIO, 0xa0, struct kvm_pit_state2)
+#define KVM_PPC_GET_PVINFO _IOW(KVMIO, 0xa1, struct kvm_ppc_pvinfo)
+#define KVM_UNPOISON_ADDRESS _IO(KVMIO, 0xa2)

/*
* ioctls for vcpu fds
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ -1619,6 +1619,45 @@ int kvm_arch_init_irq_routing(void)
}
#endif

+struct HWPoisonPage;
+typedef struct HWPoisonPage HWPoisonPage;
+struct HWPoisonPage
+{
+ void *vaddr;
+ QLIST_ENTRY(HWPoisonPage) list;
+};
+
+static QLIST_HEAD(hwpoison_page_list, HWPoisonPage) hwpoison_page_list =
+ QLIST_HEAD_INITIALIZER(hwpoison_page_list);
+
+static void kvm_unpoison_all(void *param)
+{
+ HWPoisonPage *page, *next_page;
+ unsigned long address;
+ KVMState *s = param;
+
+ QLIST_FOREACH_SAFE(page, &hwpoison_page_list, list, next_page) {
+ address = (unsigned long)page->vaddr;
+ QLIST_REMOVE(page, list);
+ kvm_vm_ioctl(s, KVM_UNPOISON_ADDRESS, address);
+ qemu_free(page);
+ }
+}
+
+void kvm_hwpoison_page_add(void *vaddr)
+{
+ HWPoisonPage *page;
+
+ QLIST_FOREACH(page, &hwpoison_page_list, list) {
+ if (page->vaddr == vaddr)
+ return;
+ }
+
+ page = qemu_malloc(sizeof(HWPoisonPage));
+ page->vaddr = vaddr;
+ QLIST_INSERT_HEAD(&hwpoison_page_list, page, list);
+}
+
extern int no_hpet;

static int kvm_create_context(void)
@@ -1703,6 +1742,7 @@ static int kvm_create_context(void)
}
#endif
}
+ qemu_register_reset(kvm_unpoison_all, kvm_state);

return 0;
}
--- a/kvm.h
+++ b/kvm.h
@@ -221,4 +221,6 @@ int kvm_irqchip_in_kernel(void);

int kvm_set_irq(int irq, int level, int *status);

+void kvm_hwpoison_page_add(void *vaddr);
+
#endif