xen: Remove event channel notification through Xen PCI platform device

Ever since commit 254d1a3f02 ("xen/pv-on-hvm kexec: shutdown watches
from old kernel") using the INTx interrupt from Xen PCI platform
device for event channel notification would just lockup the guest
during bootup.  postcore_initcall now calls xs_reset_watches which
will eventually try to read a value from XenStore and will get stuck
on read_reply at XenBus forever since the platform driver is not
probed yet and its INTx interrupt handler is not registered yet. That
means that the guest can not be notified at this moment of any pending
event channels and none of the per-event handlers will ever be invoked
(including the XenStore one) and the reply will never be picked up by
the kernel.

The exact stack where things get stuck during xenbus_init:

-xenbus_init
 -xs_init
  -xs_reset_watches
   -xenbus_scanf
    -xenbus_read
     -xs_single
      -xs_single
       -xs_talkv

Vector callbacks have always been the favourite event notification
mechanism since their introduction in commit 38e20b07ef ("x86/xen:
event channels delivery on HVM.") and the vector callback feature has
always been advertised for quite some time by Xen that's why INTx was
broken for several years now without impacting anyone.

Luckily this also means that event channel notification through INTx
is basically dead-code which can be safely removed without impacting
anybody since it has been effectively disabled for more than 4 years
with nobody complaining about it (at least as far as I'm aware of).

This commit removes event channel notification through Xen PCI
platform device.

Cc: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Cc: David Vrabel <david.vrabel@citrix.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: x86@kernel.org
Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Stefano Stabellini <stefano.stabellini@eu.citrix.com>
Cc: Julien Grall <julien.grall@citrix.com>
Cc: Vitaly Kuznetsov <vkuznets@redhat.com>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Cc: Ross Lagerwall <ross.lagerwall@citrix.com>
Cc: xen-devel@lists.xenproject.org
Cc: linux-kernel@vger.kernel.org
Cc: linux-pci@vger.kernel.org
Cc: Anthony Liguori <aliguori@amazon.com>
Signed-off-by: KarimAllah Ahmed <karahmed@amazon.de>
Reviewed-by: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
This commit is contained in:
KarimAllah Ahmed 2016-08-26 23:55:36 +02:00 committed by David Vrabel
parent c8761e2016
commit 72a9b18629
8 changed files with 17 additions and 117 deletions

View File

@ -20,15 +20,4 @@ static inline int xen_irqs_disabled(struct pt_regs *regs)
/* No need for a barrier -- XCHG is a barrier on x86. */ /* No need for a barrier -- XCHG is a barrier on x86. */
#define xchg_xen_ulong(ptr, val) xchg((ptr), (val)) #define xchg_xen_ulong(ptr, val) xchg((ptr), (val))
extern int xen_have_vector_callback;
/*
* Events delivered via platform PCI interrupts are always
* routed to vcpu 0 and hence cannot be rebound.
*/
static inline bool xen_support_evtchn_rebind(void)
{
return (!xen_hvm_domain() || xen_have_vector_callback);
}
#endif /* _ASM_X86_XEN_EVENTS_H */ #endif /* _ASM_X86_XEN_EVENTS_H */

View File

@ -456,7 +456,7 @@ void __init xen_msi_init(void)
int __init pci_xen_hvm_init(void) int __init pci_xen_hvm_init(void)
{ {
if (!xen_have_vector_callback || !xen_feature(XENFEAT_hvm_pirqs)) if (!xen_feature(XENFEAT_hvm_pirqs))
return 0; return 0;
#ifdef CONFIG_ACPI #ifdef CONFIG_ACPI

View File

@ -137,8 +137,6 @@ struct shared_info xen_dummy_shared_info;
void *xen_initial_gdt; void *xen_initial_gdt;
RESERVE_BRK(shared_info_page_brk, PAGE_SIZE); RESERVE_BRK(shared_info_page_brk, PAGE_SIZE);
__read_mostly int xen_have_vector_callback;
EXPORT_SYMBOL_GPL(xen_have_vector_callback);
static int xen_cpu_up_prepare(unsigned int cpu); static int xen_cpu_up_prepare(unsigned int cpu);
static int xen_cpu_up_online(unsigned int cpu); static int xen_cpu_up_online(unsigned int cpu);
@ -1524,10 +1522,7 @@ static void __init xen_pvh_early_guest_init(void)
if (!xen_feature(XENFEAT_auto_translated_physmap)) if (!xen_feature(XENFEAT_auto_translated_physmap))
return; return;
if (!xen_feature(XENFEAT_hvm_callback_vector)) BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector));
return;
xen_have_vector_callback = 1;
xen_pvh_early_cpu_init(0, false); xen_pvh_early_cpu_init(0, false);
xen_pvh_set_cr_flags(0); xen_pvh_set_cr_flags(0);
@ -1864,9 +1859,7 @@ static int xen_cpu_up_prepare(unsigned int cpu)
xen_vcpu_setup(cpu); xen_vcpu_setup(cpu);
} }
if (xen_pv_domain() || if (xen_pv_domain() || xen_feature(XENFEAT_hvm_safe_pvclock))
(xen_have_vector_callback &&
xen_feature(XENFEAT_hvm_safe_pvclock)))
xen_setup_timer(cpu); xen_setup_timer(cpu);
rc = xen_smp_intr_init(cpu); rc = xen_smp_intr_init(cpu);
@ -1882,9 +1875,7 @@ static int xen_cpu_dead(unsigned int cpu)
{ {
xen_smp_intr_free(cpu); xen_smp_intr_free(cpu);
if (xen_pv_domain() || if (xen_pv_domain() || xen_feature(XENFEAT_hvm_safe_pvclock))
(xen_have_vector_callback &&
xen_feature(XENFEAT_hvm_safe_pvclock)))
xen_teardown_timer(cpu); xen_teardown_timer(cpu);
return 0; return 0;
@ -1922,8 +1913,8 @@ static void __init xen_hvm_guest_init(void)
xen_panic_handler_init(); xen_panic_handler_init();
if (xen_feature(XENFEAT_hvm_callback_vector)) BUG_ON(!xen_feature(XENFEAT_hvm_callback_vector));
xen_have_vector_callback = 1;
xen_hvm_smp_init(); xen_hvm_smp_init();
WARN_ON(xen_cpuhp_setup()); WARN_ON(xen_cpuhp_setup());
xen_unplug_emulated_devices(); xen_unplug_emulated_devices();
@ -1961,7 +1952,7 @@ bool xen_hvm_need_lapic(void)
return false; return false;
if (!xen_hvm_domain()) if (!xen_hvm_domain())
return false; return false;
if (xen_feature(XENFEAT_hvm_pirqs) && xen_have_vector_callback) if (xen_feature(XENFEAT_hvm_pirqs))
return false; return false;
return true; return true;
} }

View File

@ -765,8 +765,6 @@ static void __init xen_hvm_smp_prepare_cpus(unsigned int max_cpus)
void __init xen_hvm_smp_init(void) void __init xen_hvm_smp_init(void)
{ {
if (!xen_have_vector_callback)
return;
smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus; smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus;
smp_ops.smp_send_reschedule = xen_smp_send_reschedule; smp_ops.smp_send_reschedule = xen_smp_send_reschedule;
smp_ops.cpu_die = xen_cpu_die; smp_ops.cpu_die = xen_cpu_die;

View File

@ -432,11 +432,6 @@ static void xen_hvm_setup_cpu_clockevents(void)
void __init xen_hvm_init_time_ops(void) void __init xen_hvm_init_time_ops(void)
{ {
/* vector callback is needed otherwise we cannot receive interrupts
* on cpu > 0 and at this point we don't know how many cpus are
* available */
if (!xen_have_vector_callback)
return;
if (!xen_feature(XENFEAT_hvm_safe_pvclock)) { if (!xen_feature(XENFEAT_hvm_safe_pvclock)) {
printk(KERN_INFO "Xen doesn't support pvclock on HVM," printk(KERN_INFO "Xen doesn't support pvclock on HVM,"
"disable pv timer\n"); "disable pv timer\n");

View File

@ -1314,9 +1314,6 @@ static int rebind_irq_to_cpu(unsigned irq, unsigned tcpu)
if (!VALID_EVTCHN(evtchn)) if (!VALID_EVTCHN(evtchn))
return -1; return -1;
if (!xen_support_evtchn_rebind())
return -1;
/* Send future instances of this interrupt to other vcpu. */ /* Send future instances of this interrupt to other vcpu. */
bind_vcpu.port = evtchn; bind_vcpu.port = evtchn;
bind_vcpu.vcpu = xen_vcpu_nr(tcpu); bind_vcpu.vcpu = xen_vcpu_nr(tcpu);
@ -1650,20 +1647,15 @@ void xen_callback_vector(void)
{ {
int rc; int rc;
uint64_t callback_via; uint64_t callback_via;
if (xen_have_vector_callback) {
callback_via = HVM_CALLBACK_VECTOR(HYPERVISOR_CALLBACK_VECTOR); callback_via = HVM_CALLBACK_VECTOR(HYPERVISOR_CALLBACK_VECTOR);
rc = xen_set_callback_via(callback_via); rc = xen_set_callback_via(callback_via);
if (rc) { BUG_ON(rc);
pr_err("Request for Xen HVM callback vector failed\n"); pr_info("Xen HVM callback vector for event delivery is enabled\n");
xen_have_vector_callback = 0; /* in the restore case the vector has already been allocated */
return; if (!test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors))
} alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR,
pr_info("Xen HVM callback vector for event delivery is enabled\n"); xen_hvm_callback_vector);
/* in the restore case the vector has already been allocated */
if (!test_bit(HYPERVISOR_CALLBACK_VECTOR, used_vectors))
alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR,
xen_hvm_callback_vector);
}
} }
#else #else
void xen_callback_vector(void) {} void xen_callback_vector(void) {}

View File

@ -42,7 +42,6 @@
static unsigned long platform_mmio; static unsigned long platform_mmio;
static unsigned long platform_mmio_alloc; static unsigned long platform_mmio_alloc;
static unsigned long platform_mmiolen; static unsigned long platform_mmiolen;
static uint64_t callback_via;
static unsigned long alloc_xen_mmio(unsigned long len) static unsigned long alloc_xen_mmio(unsigned long len)
{ {
@ -55,51 +54,6 @@ static unsigned long alloc_xen_mmio(unsigned long len)
return addr; return addr;
} }
static uint64_t get_callback_via(struct pci_dev *pdev)
{
u8 pin;
int irq;
irq = pdev->irq;
if (irq < 16)
return irq; /* ISA IRQ */
pin = pdev->pin;
/* We don't know the GSI. Specify the PCI INTx line instead. */
return ((uint64_t)0x01 << 56) | /* PCI INTx identifier */
((uint64_t)pci_domain_nr(pdev->bus) << 32) |
((uint64_t)pdev->bus->number << 16) |
((uint64_t)(pdev->devfn & 0xff) << 8) |
((uint64_t)(pin - 1) & 3);
}
static irqreturn_t do_hvm_evtchn_intr(int irq, void *dev_id)
{
xen_hvm_evtchn_do_upcall();
return IRQ_HANDLED;
}
static int xen_allocate_irq(struct pci_dev *pdev)
{
return request_irq(pdev->irq, do_hvm_evtchn_intr,
IRQF_NOBALANCING | IRQF_TRIGGER_RISING,
"xen-platform-pci", pdev);
}
static int platform_pci_resume(struct pci_dev *pdev)
{
int err;
if (xen_have_vector_callback)
return 0;
err = xen_set_callback_via(callback_via);
if (err) {
dev_err(&pdev->dev, "platform_pci_resume failure!\n");
return err;
}
return 0;
}
static int platform_pci_probe(struct pci_dev *pdev, static int platform_pci_probe(struct pci_dev *pdev,
const struct pci_device_id *ent) const struct pci_device_id *ent)
{ {
@ -138,21 +92,6 @@ static int platform_pci_probe(struct pci_dev *pdev,
platform_mmio = mmio_addr; platform_mmio = mmio_addr;
platform_mmiolen = mmio_len; platform_mmiolen = mmio_len;
if (!xen_have_vector_callback) {
ret = xen_allocate_irq(pdev);
if (ret) {
dev_warn(&pdev->dev, "request_irq failed err=%d\n", ret);
goto out;
}
callback_via = get_callback_via(pdev);
ret = xen_set_callback_via(callback_via);
if (ret) {
dev_warn(&pdev->dev, "Unable to set the evtchn callback "
"err=%d\n", ret);
goto out;
}
}
max_nr_gframes = gnttab_max_grant_frames(); max_nr_gframes = gnttab_max_grant_frames();
grant_frames = alloc_xen_mmio(PAGE_SIZE * max_nr_gframes); grant_frames = alloc_xen_mmio(PAGE_SIZE * max_nr_gframes);
ret = gnttab_setup_auto_xlat_frames(grant_frames); ret = gnttab_setup_auto_xlat_frames(grant_frames);
@ -184,9 +123,6 @@ static struct pci_driver platform_driver = {
.name = DRV_NAME, .name = DRV_NAME,
.probe = platform_pci_probe, .probe = platform_pci_probe,
.id_table = platform_pci_tbl, .id_table = platform_pci_tbl,
#ifdef CONFIG_PM
.resume_early = platform_pci_resume,
#endif
}; };
static int __init platform_pci_init(void) static int __init platform_pci_init(void)

View File

@ -38,8 +38,7 @@ extern enum xen_domain_type xen_domain_type;
*/ */
#include <xen/features.h> #include <xen/features.h>
#define xen_pvh_domain() (xen_pv_domain() && \ #define xen_pvh_domain() (xen_pv_domain() && \
xen_feature(XENFEAT_auto_translated_physmap) && \ xen_feature(XENFEAT_auto_translated_physmap))
xen_have_vector_callback)
#else #else
#define xen_pvh_domain() (0) #define xen_pvh_domain() (0)
#endif #endif