From: Greg Kroah-Hartman Date: Wed, 4 Mar 2015 04:45:30 +0000 (-0800) Subject: 3.18-stable patches X-Git-Tag: v3.10.71~19 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=233c0d4facbf4a35156a5b577cb6e9908373d8ea;p=thirdparty%2Fkernel%2Fstable-queue.git 3.18-stable patches added patches: arm64-compat-fix-siginfo_t-compat_siginfo_t-conversion-on-big-endian.patch hx4700-regulator-declare-full-constraints.patch kvm-s390-avoid-memory-leaks-if-__inject_vm-fails.patch kvm-s390-base-hrtimer-on-a-monotonic-clock.patch kvm-s390-floating-irqs-fix-user-triggerable-endless-loop.patch kvm-s390-forward-hrtimer-if-guest-ckc-not-pending-yet.patch kvm-x86-update-masterclock-values-on-tsc-writes.patch x86-xen-treat-sci-interrupt-as-normal-gsi-interrupt.patch --- diff --git a/queue-3.18/arm64-compat-fix-siginfo_t-compat_siginfo_t-conversion-on-big-endian.patch b/queue-3.18/arm64-compat-fix-siginfo_t-compat_siginfo_t-conversion-on-big-endian.patch new file mode 100644 index 00000000000..7b95bf8aafc --- /dev/null +++ b/queue-3.18/arm64-compat-fix-siginfo_t-compat_siginfo_t-conversion-on-big-endian.patch @@ -0,0 +1,51 @@ +From 9d42d48a342aee208c1154696196497fdc556bbf Mon Sep 17 00:00:00 2001 +From: Catalin Marinas +Date: Mon, 23 Feb 2015 15:13:40 +0000 +Subject: arm64: compat Fix siginfo_t -> compat_siginfo_t conversion on big endian + +From: Catalin Marinas + +commit 9d42d48a342aee208c1154696196497fdc556bbf upstream. + +The native (64-bit) sigval_t union contains sival_int (32-bit) and +sival_ptr (64-bit). When a compat application invokes a syscall that +takes a sigval_t value (as part of a larger structure, e.g. +compat_sys_mq_notify, compat_sys_timer_create), the compat_sigval_t +union is converted to the native sigval_t with sival_int overlapping +with either the least or the most significant half of sival_ptr, +depending on endianness. When the corresponding signal is delivered to a +compat application, on big endian the current (compat_uptr_t)sival_ptr +cast always returns 0 since sival_int corresponds to the top part of +sival_ptr. This patch fixes copy_siginfo_to_user32() so that sival_int +is copied to the compat_siginfo_t structure. + +Reported-by: Bamvor Jian Zhang +Tested-by: Bamvor Jian Zhang +Signed-off-by: Catalin Marinas +Signed-off-by: Greg Kroah-Hartman + +--- + arch/arm64/kernel/signal32.c | 5 ++--- + 1 file changed, 2 insertions(+), 3 deletions(-) + +--- a/arch/arm64/kernel/signal32.c ++++ b/arch/arm64/kernel/signal32.c +@@ -154,8 +154,7 @@ int copy_siginfo_to_user32(compat_siginf + case __SI_TIMER: + err |= __put_user(from->si_tid, &to->si_tid); + err |= __put_user(from->si_overrun, &to->si_overrun); +- err |= __put_user((compat_uptr_t)(unsigned long)from->si_ptr, +- &to->si_ptr); ++ err |= __put_user(from->si_int, &to->si_int); + break; + case __SI_POLL: + err |= __put_user(from->si_band, &to->si_band); +@@ -184,7 +183,7 @@ int copy_siginfo_to_user32(compat_siginf + case __SI_MESGQ: /* But this is */ + err |= __put_user(from->si_pid, &to->si_pid); + err |= __put_user(from->si_uid, &to->si_uid); +- err |= __put_user((compat_uptr_t)(unsigned long)from->si_ptr, &to->si_ptr); ++ err |= __put_user(from->si_int, &to->si_int); + break; + default: /* this is just in case for now ... */ + err |= __put_user(from->si_pid, &to->si_pid); diff --git a/queue-3.18/hx4700-regulator-declare-full-constraints.patch b/queue-3.18/hx4700-regulator-declare-full-constraints.patch new file mode 100644 index 00000000000..80e92a36d95 --- /dev/null +++ b/queue-3.18/hx4700-regulator-declare-full-constraints.patch @@ -0,0 +1,32 @@ +From a52d209336f8fc7483a8c7f4a8a7d2a8e1692a6c Mon Sep 17 00:00:00 2001 +From: Martin Vajnar +Date: Wed, 24 Dec 2014 00:27:57 +0100 +Subject: hx4700: regulator: declare full constraints + +From: Martin Vajnar + +commit a52d209336f8fc7483a8c7f4a8a7d2a8e1692a6c upstream. + +Since the removal of CONFIG_REGULATOR_DUMMY option, the touchscreen stopped +working. This patch enables the "replacement" for REGULATOR_DUMMY and +allows the touchscreen to work even though there is no regulator for "vcc". + +Signed-off-by: Martin Vajnar +Signed-off-by: Robert Jarzmik +Signed-off-by: Greg Kroah-Hartman + +--- + arch/arm/mach-pxa/hx4700.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/arch/arm/mach-pxa/hx4700.c ++++ b/arch/arm/mach-pxa/hx4700.c +@@ -893,6 +893,8 @@ static void __init hx4700_init(void) + mdelay(10); + gpio_set_value(GPIO71_HX4700_ASIC3_nRESET, 1); + mdelay(10); ++ ++ regulator_has_full_constraints(); + } + + MACHINE_START(H4700, "HP iPAQ HX4700") diff --git a/queue-3.18/kvm-s390-avoid-memory-leaks-if-__inject_vm-fails.patch b/queue-3.18/kvm-s390-avoid-memory-leaks-if-__inject_vm-fails.patch new file mode 100644 index 00000000000..8205bf53f6d --- /dev/null +++ b/queue-3.18/kvm-s390-avoid-memory-leaks-if-__inject_vm-fails.patch @@ -0,0 +1,46 @@ +From 428d53be5e7468769d4e7899cca06ed5f783a6e1 Mon Sep 17 00:00:00 2001 +From: David Hildenbrand +Date: Fri, 16 Jan 2015 12:58:09 +0100 +Subject: KVM: s390: avoid memory leaks if __inject_vm() fails + +From: David Hildenbrand + +commit 428d53be5e7468769d4e7899cca06ed5f783a6e1 upstream. + +We have to delete the allocated interrupt info if __inject_vm() fails. + +Otherwise user space can keep flooding kvm with floating interrupts and +provoke more and more memory leaks. + +Reported-by: Dominik Dingel +Reviewed-by: Dominik Dingel +Signed-off-by: David Hildenbrand +Signed-off-by: Christian Borntraeger +Signed-off-by: Greg Kroah-Hartman + +--- + arch/s390/kvm/interrupt.c | 6 +++++- + 1 file changed, 5 insertions(+), 1 deletion(-) + +--- a/arch/s390/kvm/interrupt.c ++++ b/arch/s390/kvm/interrupt.c +@@ -876,6 +876,7 @@ int kvm_s390_inject_vm(struct kvm *kvm, + struct kvm_s390_interrupt *s390int) + { + struct kvm_s390_interrupt_info *inti; ++ int rc; + + inti = kzalloc(sizeof(*inti), GFP_KERNEL); + if (!inti) +@@ -923,7 +924,10 @@ int kvm_s390_inject_vm(struct kvm *kvm, + trace_kvm_s390_inject_vm(s390int->type, s390int->parm, s390int->parm64, + 2); + +- return __inject_vm(kvm, inti); ++ rc = __inject_vm(kvm, inti); ++ if (rc) ++ kfree(inti); ++ return rc; + } + + void kvm_s390_reinject_io_int(struct kvm *kvm, diff --git a/queue-3.18/kvm-s390-base-hrtimer-on-a-monotonic-clock.patch b/queue-3.18/kvm-s390-base-hrtimer-on-a-monotonic-clock.patch new file mode 100644 index 00000000000..2f943b9523a --- /dev/null +++ b/queue-3.18/kvm-s390-base-hrtimer-on-a-monotonic-clock.patch @@ -0,0 +1,34 @@ +From 0ac96caf0f9381088c673a16d910b1d329670edf Mon Sep 17 00:00:00 2001 +From: David Hildenbrand +Date: Fri, 12 Dec 2014 15:17:31 +0100 +Subject: KVM: s390: base hrtimer on a monotonic clock + +From: David Hildenbrand + +commit 0ac96caf0f9381088c673a16d910b1d329670edf upstream. + +The hrtimer that handles the wait with enabled timer interrupts +should not be disturbed by changes of the host time. + +This patch changes our hrtimer to be based on a monotonic clock. + +Signed-off-by: David Hildenbrand +Acked-by: Cornelia Huck +Signed-off-by: Christian Borntraeger +Signed-off-by: Greg Kroah-Hartman + +--- + arch/s390/kvm/kvm-s390.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/arch/s390/kvm/kvm-s390.c ++++ b/arch/s390/kvm/kvm-s390.c +@@ -662,7 +662,7 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu + if (rc) + return rc; + } +- hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); ++ hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); + vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup; + get_cpu_id(&vcpu->arch.cpu_id); + vcpu->arch.cpu_id.version = 0xff; diff --git a/queue-3.18/kvm-s390-floating-irqs-fix-user-triggerable-endless-loop.patch b/queue-3.18/kvm-s390-floating-irqs-fix-user-triggerable-endless-loop.patch new file mode 100644 index 00000000000..434859544a1 --- /dev/null +++ b/queue-3.18/kvm-s390-floating-irqs-fix-user-triggerable-endless-loop.patch @@ -0,0 +1,36 @@ +From 8e2207cdd087ebb031e9118d1fd0902c6533a5e5 Mon Sep 17 00:00:00 2001 +From: David Hildenbrand +Date: Thu, 15 Jan 2015 17:56:18 +0100 +Subject: KVM: s390: floating irqs: fix user triggerable endless loop + +From: David Hildenbrand + +commit 8e2207cdd087ebb031e9118d1fd0902c6533a5e5 upstream. + +If a vm with no VCPUs is created, the injection of a floating irq +leads to an endless loop in the kernel. + +Let's skip the search for a destination VCPU for a floating irq if no +VCPUs were created. + +Reviewed-by: Dominik Dingel +Reviewed-by: Cornelia Huck +Signed-off-by: David Hildenbrand +Signed-off-by: Christian Borntraeger +Signed-off-by: Greg Kroah-Hartman + +--- + arch/s390/kvm/interrupt.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/arch/s390/kvm/interrupt.c ++++ b/arch/s390/kvm/interrupt.c +@@ -850,6 +850,8 @@ static int __inject_vm(struct kvm *kvm, + list_add_tail(&inti->list, &iter->list); + } + atomic_set(&fi->active, 1); ++ if (atomic_read(&kvm->online_vcpus) == 0) ++ goto unlock_fi; + sigcpu = find_first_bit(fi->idle_mask, KVM_MAX_VCPUS); + if (sigcpu == KVM_MAX_VCPUS) { + do { diff --git a/queue-3.18/kvm-s390-forward-hrtimer-if-guest-ckc-not-pending-yet.patch b/queue-3.18/kvm-s390-forward-hrtimer-if-guest-ckc-not-pending-yet.patch new file mode 100644 index 00000000000..9e0457dc2d3 --- /dev/null +++ b/queue-3.18/kvm-s390-forward-hrtimer-if-guest-ckc-not-pending-yet.patch @@ -0,0 +1,78 @@ +From 2d00f759427bb3ed963b60f570830e9eca7e1c69 Mon Sep 17 00:00:00 2001 +From: David Hildenbrand +Date: Thu, 11 Dec 2014 10:18:01 +0100 +Subject: KVM: s390: forward hrtimer if guest ckc not pending yet + +From: David Hildenbrand + +commit 2d00f759427bb3ed963b60f570830e9eca7e1c69 upstream. + +Patch 0759d0681cae ("KVM: s390: cleanup handle_wait by reusing +kvm_vcpu_block") changed the way pending guest clock comparator +interrupts are detected. It was assumed that as soon as the hrtimer +wakes up, the condition for the guest ckc is satisfied. + +This is however only true as long as adjclock() doesn't speed +up the monotonic clock. Reason is that the hrtimer is based on +CLOCK_MONOTONIC, the guest clock comparator detection is based +on the raw TOD clock. If CLOCK_MONOTONIC runs faster than the +TOD clock, the hrtimer wakes the target VCPU up too early and +the target VCPU will not detect any pending interrupts, therefore +going back to sleep. It will never be woken up again because the +hrtimer has finished. The VCPU is stuck. + +As a quick fix, we have to forward the hrtimer until the guest +clock comparator is really due, to guarantee properly timed wake +ups. + +As the hrtimer callback might be triggered on another cpu, we +have to make sure that the timer is really stopped and not currently +executing the callback on another cpu. This can happen if the vcpu +thread is scheduled onto another physical cpu, but the timer base +is not migrated. So lets use hrtimer_cancel instead of try_to_cancel. + +A proper fix might be to introduce a RAW based hrtimer. + +Reported-by: Christian Borntraeger +Signed-off-by: David Hildenbrand +Acked-by: Cornelia Huck +Signed-off-by: Christian Borntraeger +Signed-off-by: Greg Kroah-Hartman + +--- + arch/s390/kvm/interrupt.c | 14 ++++++++++++-- + 1 file changed, 12 insertions(+), 2 deletions(-) + +--- a/arch/s390/kvm/interrupt.c ++++ b/arch/s390/kvm/interrupt.c +@@ -613,7 +613,7 @@ no_timer: + __unset_cpu_idle(vcpu); + vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); + +- hrtimer_try_to_cancel(&vcpu->arch.ckc_timer); ++ hrtimer_cancel(&vcpu->arch.ckc_timer); + return 0; + } + +@@ -633,10 +633,20 @@ void kvm_s390_vcpu_wakeup(struct kvm_vcp + enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer) + { + struct kvm_vcpu *vcpu; ++ u64 now, sltime; + + vcpu = container_of(timer, struct kvm_vcpu, arch.ckc_timer); +- kvm_s390_vcpu_wakeup(vcpu); ++ now = get_tod_clock_fast() + vcpu->arch.sie_block->epoch; ++ sltime = tod_to_ns(vcpu->arch.sie_block->ckc - now); + ++ /* ++ * If the monotonic clock runs faster than the tod clock we might be ++ * woken up too early and have to go back to sleep to avoid deadlocks. ++ */ ++ if (vcpu->arch.sie_block->ckc > now && ++ hrtimer_forward_now(timer, ns_to_ktime(sltime))) ++ return HRTIMER_RESTART; ++ kvm_s390_vcpu_wakeup(vcpu); + return HRTIMER_NORESTART; + } + diff --git a/queue-3.18/kvm-x86-update-masterclock-values-on-tsc-writes.patch b/queue-3.18/kvm-x86-update-masterclock-values-on-tsc-writes.patch new file mode 100644 index 00000000000..2c4bda1ec3e --- /dev/null +++ b/queue-3.18/kvm-x86-update-masterclock-values-on-tsc-writes.patch @@ -0,0 +1,60 @@ +From 7f187922ddf6b67f2999a76dcb71663097b75497 Mon Sep 17 00:00:00 2001 +From: Marcelo Tosatti +Date: Tue, 4 Nov 2014 21:30:44 -0200 +Subject: KVM: x86: update masterclock values on TSC writes + +From: Marcelo Tosatti + +commit 7f187922ddf6b67f2999a76dcb71663097b75497 upstream. + +When the guest writes to the TSC, the masterclock TSC copy must be +updated as well along with the TSC_OFFSET update, otherwise a negative +tsc_timestamp is calculated at kvm_guest_time_update. + +Once "if (!vcpus_matched && ka->use_master_clock)" is simplified to +"if (ka->use_master_clock)", the corresponding "if (!ka->use_master_clock)" +becomes redundant, so remove the do_request boolean and collapse +everything into a single condition. + +Signed-off-by: Marcelo Tosatti +Signed-off-by: Paolo Bonzini +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/kvm/x86.c | 19 ++++++++++--------- + 1 file changed, 10 insertions(+), 9 deletions(-) + +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -1237,21 +1237,22 @@ void kvm_track_tsc_matching(struct kvm_v + { + #ifdef CONFIG_X86_64 + bool vcpus_matched; +- bool do_request = false; + struct kvm_arch *ka = &vcpu->kvm->arch; + struct pvclock_gtod_data *gtod = &pvclock_gtod_data; + + vcpus_matched = (ka->nr_vcpus_matched_tsc + 1 == + atomic_read(&vcpu->kvm->online_vcpus)); + +- if (vcpus_matched && gtod->clock.vclock_mode == VCLOCK_TSC) +- if (!ka->use_master_clock) +- do_request = 1; +- +- if (!vcpus_matched && ka->use_master_clock) +- do_request = 1; +- +- if (do_request) ++ /* ++ * Once the masterclock is enabled, always perform request in ++ * order to update it. ++ * ++ * In order to enable masterclock, the host clocksource must be TSC ++ * and the vcpus need to have matched TSCs. When that happens, ++ * perform request to enable masterclock. ++ */ ++ if (ka->use_master_clock || ++ (gtod->clock.vclock_mode == VCLOCK_TSC && vcpus_matched)) + kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu); + + trace_kvm_track_tsc(vcpu->vcpu_id, ka->nr_vcpus_matched_tsc, diff --git a/queue-3.18/series b/queue-3.18/series index daacfa1225a..c8c9319cc5c 100644 --- a/queue-3.18/series +++ b/queue-3.18/series @@ -121,3 +121,11 @@ arc-fix-page-address-calculation-if-page_offset-linux_link_base.patch mips-htw-prevent-accidental-htw-start-due-to-nested-htw_-start-stop.patch udf-remove-repeated-loads-blocksize.patch udf-check-length-of-extended-attributes-and-allocation-descriptors.patch +kvm-x86-update-masterclock-values-on-tsc-writes.patch +kvm-s390-forward-hrtimer-if-guest-ckc-not-pending-yet.patch +kvm-s390-base-hrtimer-on-a-monotonic-clock.patch +kvm-s390-floating-irqs-fix-user-triggerable-endless-loop.patch +kvm-s390-avoid-memory-leaks-if-__inject_vm-fails.patch +x86-xen-treat-sci-interrupt-as-normal-gsi-interrupt.patch +hx4700-regulator-declare-full-constraints.patch +arm64-compat-fix-siginfo_t-compat_siginfo_t-conversion-on-big-endian.patch diff --git a/queue-3.18/x86-xen-treat-sci-interrupt-as-normal-gsi-interrupt.patch b/queue-3.18/x86-xen-treat-sci-interrupt-as-normal-gsi-interrupt.patch new file mode 100644 index 00000000000..70a3f120db8 --- /dev/null +++ b/queue-3.18/x86-xen-treat-sci-interrupt-as-normal-gsi-interrupt.patch @@ -0,0 +1,155 @@ +From b568b8601f05a591a7ff09d8ee1cedb5b2e815fe Mon Sep 17 00:00:00 2001 +From: Jiang Liu +Date: Tue, 20 Jan 2015 10:21:05 +0800 +Subject: x86/xen: Treat SCI interrupt as normal GSI interrupt + +From: Jiang Liu + +commit b568b8601f05a591a7ff09d8ee1cedb5b2e815fe upstream. + +Currently Xen Domain0 has special treatment for ACPI SCI interrupt, +that is initialize irq for ACPI SCI at early stage in a special way as: +xen_init_IRQ() + ->pci_xen_initial_domain() + ->xen_setup_acpi_sci() + Allocate and initialize irq for ACPI SCI + +Function xen_setup_acpi_sci() calls acpi_gsi_to_irq() to get an irq +number for ACPI SCI. But unfortunately acpi_gsi_to_irq() depends on +IOAPIC irqdomains through following path +acpi_gsi_to_irq() + ->mp_map_gsi_to_irq() + ->mp_map_pin_to_irq() + ->check IOAPIC irqdomain + +For PV domains, it uses Xen event based interrupt manangement and +doesn't make uses of native IOAPIC, so no irqdomains created for IOAPIC. +This causes Xen domain0 fail to install interrupt handler for ACPI SCI +and all ACPI events will be lost. Please refer to: +https://lkml.org/lkml/2014/12/19/178 + +So the fix is to get rid of special treatment for ACPI SCI, just treat +ACPI SCI as normal GSI interrupt as: +acpi_gsi_to_irq() + ->acpi_register_gsi() + ->acpi_register_gsi_xen() + ->xen_register_gsi() + +With above change, there's no need for xen_setup_acpi_sci() anymore. +The above change also works with bare metal kernel too. + +Signed-off-by: Jiang Liu +Tested-by: Sander Eikelenboom +Cc: Tony Luck +Cc: xen-devel@lists.xenproject.org +Cc: Konrad Rzeszutek Wilk +Cc: David Vrabel +Cc: Rafael J. Wysocki +Cc: Len Brown +Cc: Pavel Machek +Cc: Bjorn Helgaas +Link: http://lkml.kernel.org/r/1421720467-7709-2-git-send-email-jiang.liu@linux.intel.com +Signed-off-by: Thomas Gleixner +Signed-off-by: Stefan Bader +Signed-off-by: Greg Kroah-Hartman + +--- + arch/x86/kernel/acpi/boot.c | 21 ++++++++++--------- + arch/x86/pci/xen.c | 47 -------------------------------------------- + 2 files changed, 11 insertions(+), 57 deletions(-) + +--- a/arch/x86/kernel/acpi/boot.c ++++ b/arch/x86/kernel/acpi/boot.c +@@ -604,18 +604,19 @@ void __init acpi_pic_sci_set_trigger(uns + + int acpi_gsi_to_irq(u32 gsi, unsigned int *irqp) + { +- int irq; ++ int rc, irq, trigger, polarity; + +- if (acpi_irq_model == ACPI_IRQ_MODEL_PIC) { +- *irqp = gsi; +- } else { +- irq = mp_map_gsi_to_irq(gsi, +- IOAPIC_MAP_ALLOC | IOAPIC_MAP_CHECK); +- if (irq < 0) +- return -1; +- *irqp = irq; ++ rc = acpi_get_override_irq(gsi, &trigger, &polarity); ++ if (rc == 0) { ++ trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE; ++ polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; ++ irq = acpi_register_gsi(NULL, gsi, trigger, polarity); ++ if (irq >= 0) { ++ *irqp = irq; ++ return 0; ++ } + } +- return 0; ++ return -1; + } + EXPORT_SYMBOL_GPL(acpi_gsi_to_irq); + +--- a/arch/x86/pci/xen.c ++++ b/arch/x86/pci/xen.c +@@ -452,52 +452,6 @@ int __init pci_xen_hvm_init(void) + } + + #ifdef CONFIG_XEN_DOM0 +-static __init void xen_setup_acpi_sci(void) +-{ +- int rc; +- int trigger, polarity; +- int gsi = acpi_sci_override_gsi; +- int irq = -1; +- int gsi_override = -1; +- +- if (!gsi) +- return; +- +- rc = acpi_get_override_irq(gsi, &trigger, &polarity); +- if (rc) { +- printk(KERN_WARNING "xen: acpi_get_override_irq failed for acpi" +- " sci, rc=%d\n", rc); +- return; +- } +- trigger = trigger ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE; +- polarity = polarity ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; +- +- printk(KERN_INFO "xen: sci override: global_irq=%d trigger=%d " +- "polarity=%d\n", gsi, trigger, polarity); +- +- /* Before we bind the GSI to a Linux IRQ, check whether +- * we need to override it with bus_irq (IRQ) value. Usually for +- * IRQs below IRQ_LEGACY_IRQ this holds IRQ == GSI, as so: +- * ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 9 low level) +- * but there are oddballs where the IRQ != GSI: +- * ACPI: INT_SRC_OVR (bus 0 bus_irq 9 global_irq 20 low level) +- * which ends up being: gsi_to_irq[9] == 20 +- * (which is what acpi_gsi_to_irq ends up calling when starting the +- * the ACPI interpreter and keels over since IRQ 9 has not been +- * setup as we had setup IRQ 20 for it). +- */ +- if (acpi_gsi_to_irq(gsi, &irq) == 0) { +- /* Use the provided value if it's valid. */ +- if (irq >= 0) +- gsi_override = irq; +- } +- +- gsi = xen_register_gsi(gsi, gsi_override, trigger, polarity); +- printk(KERN_INFO "xen: acpi sci %d\n", gsi); +- +- return; +-} +- + int __init pci_xen_initial_domain(void) + { + int irq; +@@ -509,7 +463,6 @@ int __init pci_xen_initial_domain(void) + x86_msi.msi_mask_irq = xen_nop_msi_mask_irq; + x86_msi.msix_mask_irq = xen_nop_msix_mask_irq; + #endif +- xen_setup_acpi_sci(); + __acpi_register_gsi = acpi_register_gsi_xen; + /* Pre-allocate legacy irqs */ + for (irq = 0; irq < nr_legacy_irqs(); irq++) {