6 files changed, 203 insertions, 82 deletions

diff --git a/virt/kvm/assigned-dev.c b/virt/kvm/assigned-dev.c
index 3642239252b0..f4c7f591b5d8 100644
--- a/virt/kvm/assigned-dev.c
+++ b/virt/kvm/assigned-dev.c
@@ -80,11 +80,12 @@ kvm_assigned_dev_raise_guest_irq(struct kvm_assigned_dev_kernel *assigned_dev,
                 spin_lock(&assigned_dev->intx_mask_lock);
                 if (!(assigned_dev->flags & KVM_DEV_ASSIGN_MASK_INTX))
                         kvm_set_irq(assigned_dev->kvm,
-                                    assigned_dev->irq_source_id, vector, 1);
+                                    assigned_dev->irq_source_id, vector, 1,
+                                    false);
                 spin_unlock(&assigned_dev->intx_mask_lock);
         } else
                 kvm_set_irq(assigned_dev->kvm, assigned_dev->irq_source_id,
-                            vector, 1);
+                            vector, 1, false);
 }
 
 static irqreturn_t kvm_assigned_dev_thread_intx(int irq, void *dev_id)
@@ -165,7 +166,7 @@ static void kvm_assigned_dev_ack_irq(struct kvm_irq_ack_notifier *kian)
                 container_of(kian, struct kvm_assigned_dev_kernel,
                              ack_notifier);
 
-        kvm_set_irq(dev->kvm, dev->irq_source_id, dev->guest_irq, 0);
+        kvm_set_irq(dev->kvm, dev->irq_source_id, dev->guest_irq, 0, false);
 
         spin_lock(&dev->intx_mask_lock);
 
@@ -188,7 +189,7 @@ static void kvm_assigned_dev_ack_irq(struct kvm_irq_ack_notifier *kian)
 
                 if (reassert)
                         kvm_set_irq(dev->kvm, dev->irq_source_id,
-                                    dev->guest_irq, 1);
+                                    dev->guest_irq, 1, false);
         }
 
         spin_unlock(&dev->intx_mask_lock);
@@ -202,7 +203,7 @@ static void deassign_guest_irq(struct kvm *kvm,
                                                 &assigned_dev->ack_notifier);
 
         kvm_set_irq(assigned_dev->kvm, assigned_dev->irq_source_id,
-                    assigned_dev->guest_irq, 0);
+                    assigned_dev->guest_irq, 0, false);
 
         if (assigned_dev->irq_source_id != -1)
                 kvm_free_irq_source_id(kvm, assigned_dev->irq_source_id);
@@ -901,7 +902,7 @@ static int kvm_vm_ioctl_set_pci_irq_mask(struct kvm *kvm,
         if (match->irq_requested_type & KVM_DEV_IRQ_GUEST_INTX) {
                 if (assigned_dev->flags & KVM_DEV_ASSIGN_MASK_INTX) {
                         kvm_set_irq(match->kvm, match->irq_source_id,
-                                    match->guest_irq, 0);
+                                    match->guest_irq, 0, false);
                         /*
                          * Masking at hardware-level is performed on demand,
                          * i.e. when an IRQ actually arrives at the host.
diff --git a/virt/kvm/eventfd.c b/virt/kvm/eventfd.c
index 020522ed9094..c5d43ffbf1f3 100644
--- a/virt/kvm/eventfd.c
+++ b/virt/kvm/eventfd.c
@@ -100,11 +100,13 @@ irqfd_inject(struct work_struct *work)
         struct kvm *kvm = irqfd->kvm;
 
         if (!irqfd->resampler) {
-                kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, irqfd->gsi, 1);
-                kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, irqfd->gsi, 0);
+                kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, irqfd->gsi, 1,
+                                false);
+                kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, irqfd->gsi, 0,
+                                false);
         } else
                 kvm_set_irq(kvm, KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID,
-                            irqfd->gsi, 1);
+                            irqfd->gsi, 1, false);
 }
 
 /*
@@ -121,7 +123,7 @@ irqfd_resampler_ack(struct kvm_irq_ack_notifier *kian)
         resampler = container_of(kian, struct _irqfd_resampler, notifier);
 
         kvm_set_irq(resampler->kvm, KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID,
-                    resampler->notifier.gsi, 0);
+                    resampler->notifier.gsi, 0, false);
 
         rcu_read_lock();
 
@@ -146,7 +148,7 @@ irqfd_resampler_shutdown(struct _irqfd *irqfd)
                 list_del(&resampler->link);
                 kvm_unregister_irq_ack_notifier(kvm, &resampler->notifier);
                 kvm_set_irq(kvm, KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID,
-                            resampler->notifier.gsi, 0);
+                            resampler->notifier.gsi, 0, false);
                 kfree(resampler);
         }
 
@@ -225,7 +227,8 @@ irqfd_wakeup(wait_queue_t *wait, unsigned mode, int sync, void *key)
                 irq = rcu_dereference(irqfd->irq_entry);
                 /* An event has been signaled, inject an interrupt */
                 if (irq)
-                        kvm_set_msi(irq, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1);
+                        kvm_set_msi(irq, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1,
+                                        false);
                 else
                         schedule_work(&irqfd->inject);
                 rcu_read_unlock();
@@ -574,6 +577,7 @@ struct _ioeventfd {
         struct eventfd_ctx  *eventfd;
         u64                  datamatch;
         struct kvm_io_device dev;
+        u8                   bus_idx;
         bool                 wildcard;
 };
 
@@ -666,7 +670,8 @@ ioeventfd_check_collision(struct kvm *kvm, struct _ioeventfd *p)
         struct _ioeventfd *_p;
 
         list_for_each_entry(_p, &kvm->ioeventfds, list)
-                if (_p->addr == p->addr && _p->length == p->length &&
+                if (_p->bus_idx == p->bus_idx &&
+                    _p->addr == p->addr && _p->length == p->length &&
                     (_p->wildcard || p->wildcard ||
                      _p->datamatch == p->datamatch))
                         return true;
@@ -723,6 +728,7 @@ kvm_assign_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args)
 
         INIT_LIST_HEAD(&p->list);
         p->addr    = args->addr;
+        p->bus_idx = bus_idx;
         p->length  = args->len;
         p->eventfd = eventfd;
 
@@ -781,7 +787,8 @@ kvm_deassign_ioeventfd(struct kvm *kvm, struct kvm_ioeventfd *args)
         list_for_each_entry_safe(p, tmp, &kvm->ioeventfds, list) {
                 bool wildcard = !(args->flags & KVM_IOEVENTFD_FLAG_DATAMATCH);
 
-                if (p->eventfd != eventfd  ||
+                if (p->bus_idx != bus_idx ||
+                    p->eventfd != eventfd  ||
                     p->addr != args->addr  ||
                     p->length != args->len ||
                     p->wildcard != wildcard)
diff --git a/virt/kvm/ioapic.c b/virt/kvm/ioapic.c
index 5ba005c00e2f..2d682977ce82 100644
--- a/virt/kvm/ioapic.c
+++ b/virt/kvm/ioapic.c
@@ -50,7 +50,8 @@
 #else
 #define ioapic_debug(fmt, arg...)
 #endif
-static int ioapic_deliver(struct kvm_ioapic *vioapic, int irq);
+static int ioapic_deliver(struct kvm_ioapic *vioapic, int irq,
+                bool line_status);
 
 static unsigned long ioapic_read_indirect(struct kvm_ioapic *ioapic,
                                           unsigned long addr,
@@ -90,7 +91,80 @@ static unsigned long ioapic_read_indirect(struct kvm_ioapic *ioapic,
         return result;
 }
 
-static int ioapic_service(struct kvm_ioapic *ioapic, unsigned int idx)
+static void rtc_irq_eoi_tracking_reset(struct kvm_ioapic *ioapic)
+{
+        ioapic->rtc_status.pending_eoi = 0;
+        bitmap_zero(ioapic->rtc_status.dest_map, KVM_MAX_VCPUS);
+}
+
+static void __rtc_irq_eoi_tracking_restore_one(struct kvm_vcpu *vcpu)
+{
+        bool new_val, old_val;
+        struct kvm_ioapic *ioapic = vcpu->kvm->arch.vioapic;
+        union kvm_ioapic_redirect_entry *e;
+
+        e = &ioapic->redirtbl[RTC_GSI];
+        if (!kvm_apic_match_dest(vcpu, NULL, 0, e->fields.dest_id,
+                                e->fields.dest_mode))
+                return;
+
+        new_val = kvm_apic_pending_eoi(vcpu, e->fields.vector);
+        old_val = test_bit(vcpu->vcpu_id, ioapic->rtc_status.dest_map);
+
+        if (new_val == old_val)
+                return;
+
+        if (new_val) {
+                __set_bit(vcpu->vcpu_id, ioapic->rtc_status.dest_map);
+                ioapic->rtc_status.pending_eoi++;
+        } else {
+                __clear_bit(vcpu->vcpu_id, ioapic->rtc_status.dest_map);
+                ioapic->rtc_status.pending_eoi--;
+        }
+
+        WARN_ON(ioapic->rtc_status.pending_eoi < 0);
+}
+
+void kvm_rtc_eoi_tracking_restore_one(struct kvm_vcpu *vcpu)
+{
+        struct kvm_ioapic *ioapic = vcpu->kvm->arch.vioapic;
+
+        spin_lock(&ioapic->lock);
+        __rtc_irq_eoi_tracking_restore_one(vcpu);
+        spin_unlock(&ioapic->lock);
+}
+
+static void kvm_rtc_eoi_tracking_restore_all(struct kvm_ioapic *ioapic)
+{
+        struct kvm_vcpu *vcpu;
+        int i;
+
+        if (RTC_GSI >= IOAPIC_NUM_PINS)
+                return;
+
+        rtc_irq_eoi_tracking_reset(ioapic);
+        kvm_for_each_vcpu(i, vcpu, ioapic->kvm)
+            __rtc_irq_eoi_tracking_restore_one(vcpu);
+}
+
+static void rtc_irq_eoi(struct kvm_ioapic *ioapic, struct kvm_vcpu *vcpu)
+{
+        if (test_and_clear_bit(vcpu->vcpu_id, ioapic->rtc_status.dest_map))
+                --ioapic->rtc_status.pending_eoi;
+
+        WARN_ON(ioapic->rtc_status.pending_eoi < 0);
+}
+
+static bool rtc_irq_check_coalesced(struct kvm_ioapic *ioapic)
+{
+        if (ioapic->rtc_status.pending_eoi > 0)
+                return true; /* coalesced */
+
+        return false;
+}
+
+static int ioapic_service(struct kvm_ioapic *ioapic, unsigned int idx,
+                bool line_status)
 {
         union kvm_ioapic_redirect_entry *pent;
         int injected = -1;
@@ -98,7 +172,7 @@ static int ioapic_service(struct kvm_ioapic *ioapic, unsigned int idx)
         pent = &ioapic->redirtbl[idx];
 
         if (!pent->fields.mask) {
-                injected = ioapic_deliver(ioapic, idx);
+                injected = ioapic_deliver(ioapic, idx, line_status);
                 if (injected && pent->fields.trig_mode == IOAPIC_LEVEL_TRIG)
                         pent->fields.remote_irr = 1;
         }
@@ -119,41 +193,48 @@ static void update_handled_vectors(struct kvm_ioapic *ioapic)
         smp_wmb();
 }
 
-void kvm_ioapic_calculate_eoi_exitmap(struct kvm_vcpu *vcpu,
-                                        u64 *eoi_exit_bitmap)
+void kvm_ioapic_scan_entry(struct kvm_vcpu *vcpu, u64 *eoi_exit_bitmap,
+                        u32 *tmr)
 {
         struct kvm_ioapic *ioapic = vcpu->kvm->arch.vioapic;
         union kvm_ioapic_redirect_entry *e;
-        struct kvm_lapic_irq irqe;
         int index;
 
         spin_lock(&ioapic->lock);
-        /* traverse ioapic entry to set eoi exit bitmap*/
         for (index = 0; index < IOAPIC_NUM_PINS; index++) {
                 e = &ioapic->redirtbl[index];
                 if (!e->fields.mask &&
                         (e->fields.trig_mode == IOAPIC_LEVEL_TRIG ||
                          kvm_irq_has_notifier(ioapic->kvm, KVM_IRQCHIP_IOAPIC,
-                                 index))) {
-                        irqe.dest_id = e->fields.dest_id;
-                        irqe.vector = e->fields.vector;
-                        irqe.dest_mode = e->fields.dest_mode;
-                        irqe.delivery_mode = e->fields.delivery_mode << 8;
-                        kvm_calculate_eoi_exitmap(vcpu, &irqe, eoi_exit_bitmap);
+                                 index) || index == RTC_GSI)) {
+                        if (kvm_apic_match_dest(vcpu, NULL, 0,
+                                e->fields.dest_id, e->fields.dest_mode)) {
+                                __set_bit(e->fields.vector,
+                                        (unsigned long *)eoi_exit_bitmap);
+                                if (e->fields.trig_mode == IOAPIC_LEVEL_TRIG)
+                                        __set_bit(e->fields.vector,
+                                                (unsigned long *)tmr);
+                        }
                 }
         }
         spin_unlock(&ioapic->lock);
 }
-EXPORT_SYMBOL_GPL(kvm_ioapic_calculate_eoi_exitmap);
 
-void kvm_ioapic_make_eoibitmap_request(struct kvm *kvm)
+#ifdef CONFIG_X86
+void kvm_vcpu_request_scan_ioapic(struct kvm *kvm)
 {
         struct kvm_ioapic *ioapic = kvm->arch.vioapic;
 
-        if (!kvm_apic_vid_enabled(kvm) || !ioapic)
+        if (!ioapic)
                 return;
-        kvm_make_update_eoibitmap_request(kvm);
+        kvm_make_scan_ioapic_request(kvm);
 }
+#else
+void kvm_vcpu_request_scan_ioapic(struct kvm *kvm)
+{
+        return;
+}
+#endif
 
 static void ioapic_write_indirect(struct kvm_ioapic *ioapic, u32 val)
 {
@@ -195,16 +276,17 @@ static void ioapic_write_indirect(struct kvm_ioapic *ioapic, u32 val)
                         kvm_fire_mask_notifiers(ioapic->kvm, KVM_IRQCHIP_IOAPIC, index, mask_after);
                 if (e->fields.trig_mode == IOAPIC_LEVEL_TRIG
                     && ioapic->irr & (1 << index))
-                        ioapic_service(ioapic, index);
-                kvm_ioapic_make_eoibitmap_request(ioapic->kvm);
+                        ioapic_service(ioapic, index, false);
+                kvm_vcpu_request_scan_ioapic(ioapic->kvm);
                 break;
         }
 }
 
-static int ioapic_deliver(struct kvm_ioapic *ioapic, int irq)
+static int ioapic_deliver(struct kvm_ioapic *ioapic, int irq, bool line_status)
 {
         union kvm_ioapic_redirect_entry *entry = &ioapic->redirtbl[irq];
         struct kvm_lapic_irq irqe;
+        int ret;
 
         ioapic_debug("dest=%x dest_mode=%x delivery_mode=%x "
                      "vector=%x trig_mode=%x\n",
@@ -220,11 +302,19 @@ static int ioapic_deliver(struct kvm_ioapic *ioapic, int irq)
         irqe.level = 1;
         irqe.shorthand = 0;
 
-        return kvm_irq_delivery_to_apic(ioapic->kvm, NULL, &irqe);
+        if (irq == RTC_GSI && line_status) {
+                BUG_ON(ioapic->rtc_status.pending_eoi != 0);
+                ret = kvm_irq_delivery_to_apic(ioapic->kvm, NULL, &irqe,
+                                ioapic->rtc_status.dest_map);
+                ioapic->rtc_status.pending_eoi = ret;
+        } else
+                ret = kvm_irq_delivery_to_apic(ioapic->kvm, NULL, &irqe, NULL);
+
+        return ret;
 }
 
 int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int irq_source_id,
-                       int level)
+                       int level, bool line_status)
 {
         u32 old_irr;
         u32 mask = 1 << irq;
@@ -244,13 +334,20 @@ int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int irq_source_id,
                 ret = 1;
         } else {
                 int edge = (entry.fields.trig_mode == IOAPIC_EDGE_TRIG);
+
+                if (irq == RTC_GSI && line_status &&
+                        rtc_irq_check_coalesced(ioapic)) {
+                        ret = 0; /* coalesced */
+                        goto out;
+                }
                 ioapic->irr |= mask;
                 if ((edge && old_irr != ioapic->irr) ||
                     (!edge && !entry.fields.remote_irr))
-                        ret = ioapic_service(ioapic, irq);
+                        ret = ioapic_service(ioapic, irq, line_status);
                 else
                         ret = 0; /* report coalesced interrupt */
         }
+out:
         trace_kvm_ioapic_set_irq(entry.bits, irq, ret == 0);
         spin_unlock(&ioapic->lock);
 
@@ -267,8 +364,8 @@ void kvm_ioapic_clear_all(struct kvm_ioapic *ioapic, int irq_source_id)
         spin_unlock(&ioapic->lock);
 }
 
-static void __kvm_ioapic_update_eoi(struct kvm_ioapic *ioapic, int vector,
-                                     int trigger_mode)
+static void __kvm_ioapic_update_eoi(struct kvm_vcpu *vcpu,
+                        struct kvm_ioapic *ioapic, int vector, int trigger_mode)
 {
         int i;
 
@@ -278,6 +375,8 @@ static void __kvm_ioapic_update_eoi(struct kvm_ioapic *ioapic, int vector,
                 if (ent->fields.vector != vector)
                         continue;
 
+                if (i == RTC_GSI)
+                        rtc_irq_eoi(ioapic, vcpu);
                 /*
                  * We are dropping lock while calling ack notifiers because ack
                  * notifier callbacks for assigned devices call into IOAPIC
@@ -296,7 +395,7 @@ static void __kvm_ioapic_update_eoi(struct kvm_ioapic *ioapic, int vector,
                 ASSERT(ent->fields.trig_mode == IOAPIC_LEVEL_TRIG);
                 ent->fields.remote_irr = 0;
                 if (!ent->fields.mask && (ioapic->irr & (1 << i)))
-                        ioapic_service(ioapic, i);
+                        ioapic_service(ioapic, i, false);
         }
 }
 
@@ -307,12 +406,12 @@ bool kvm_ioapic_handles_vector(struct kvm *kvm, int vector)
         return test_bit(vector, ioapic->handled_vectors);
 }
 
-void kvm_ioapic_update_eoi(struct kvm *kvm, int vector, int trigger_mode)
+void kvm_ioapic_update_eoi(struct kvm_vcpu *vcpu, int vector, int trigger_mode)
 {
-        struct kvm_ioapic *ioapic = kvm->arch.vioapic;
+        struct kvm_ioapic *ioapic = vcpu->kvm->arch.vioapic;
 
         spin_lock(&ioapic->lock);
-        __kvm_ioapic_update_eoi(ioapic, vector, trigger_mode);
+        __kvm_ioapic_update_eoi(vcpu, ioapic, vector, trigger_mode);
         spin_unlock(&ioapic->lock);
 }
 
@@ -410,7 +509,7 @@ static int ioapic_mmio_write(struct kvm_io_device *this, gpa_t addr, int len,
                 break;
 #ifdef  CONFIG_IA64
         case IOAPIC_REG_EOI:
-                __kvm_ioapic_update_eoi(ioapic, data, IOAPIC_LEVEL_TRIG);
+                __kvm_ioapic_update_eoi(NULL, ioapic, data, IOAPIC_LEVEL_TRIG);
                 break;
 #endif
 
@@ -431,6 +530,7 @@ void kvm_ioapic_reset(struct kvm_ioapic *ioapic)
         ioapic->ioregsel = 0;
         ioapic->irr = 0;
         ioapic->id = 0;
+        rtc_irq_eoi_tracking_reset(ioapic);
         update_handled_vectors(ioapic);
 }
 
@@ -496,7 +596,8 @@ int kvm_set_ioapic(struct kvm *kvm, struct kvm_ioapic_state *state)
         spin_lock(&ioapic->lock);
         memcpy(ioapic, state, sizeof(struct kvm_ioapic_state));
         update_handled_vectors(ioapic);
-        kvm_ioapic_make_eoibitmap_request(kvm);
+        kvm_vcpu_request_scan_ioapic(kvm);
+        kvm_rtc_eoi_tracking_restore_all(ioapic);
         spin_unlock(&ioapic->lock);
         return 0;
 }
diff --git a/virt/kvm/ioapic.h b/virt/kvm/ioapic.h
index 0400a466c50c..615d8c995c3c 100644
--- a/virt/kvm/ioapic.h
+++ b/virt/kvm/ioapic.h
@@ -34,6 +34,17 @@ struct kvm_vcpu;
 #define IOAPIC_INIT                     0x5
 #define IOAPIC_EXTINT                   0x7
 
+#ifdef CONFIG_X86
+#define RTC_GSI 8
+#else
+#define RTC_GSI -1U
+#endif
+
+struct rtc_status {
+        int pending_eoi;
+        DECLARE_BITMAP(dest_map, KVM_MAX_VCPUS);
+};
+
 struct kvm_ioapic {
         u64 base_address;
         u32 ioregsel;
@@ -47,6 +58,7 @@ struct kvm_ioapic {
         void (*ack_notifier)(void *opaque, int irq);
         spinlock_t lock;
         DECLARE_BITMAP(handled_vectors, 256);
+        struct rtc_status rtc_status;
 };
 
 #ifdef DEBUG
@@ -67,24 +79,25 @@ static inline struct kvm_ioapic *ioapic_irqchip(struct kvm *kvm)
         return kvm->arch.vioapic;
 }
 
+void kvm_rtc_eoi_tracking_restore_one(struct kvm_vcpu *vcpu);
 int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
                 int short_hand, int dest, int dest_mode);
 int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2);
-void kvm_ioapic_update_eoi(struct kvm *kvm, int vector, int trigger_mode);
+void kvm_ioapic_update_eoi(struct kvm_vcpu *vcpu, int vector,
+                        int trigger_mode);
 bool kvm_ioapic_handles_vector(struct kvm *kvm, int vector);
 int kvm_ioapic_init(struct kvm *kvm);
 void kvm_ioapic_destroy(struct kvm *kvm);
 int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int irq_source_id,
-                       int level);
+                       int level, bool line_status);
 void kvm_ioapic_clear_all(struct kvm_ioapic *ioapic, int irq_source_id);
 void kvm_ioapic_reset(struct kvm_ioapic *ioapic);
 int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
-                struct kvm_lapic_irq *irq);
+                struct kvm_lapic_irq *irq, unsigned long *dest_map);
 int kvm_get_ioapic(struct kvm *kvm, struct kvm_ioapic_state *state);
 int kvm_set_ioapic(struct kvm *kvm, struct kvm_ioapic_state *state);
-void kvm_ioapic_make_eoibitmap_request(struct kvm *kvm);
-void kvm_ioapic_calculate_eoi_exitmap(struct kvm_vcpu *vcpu,
-                                        u64 *eoi_exit_bitmap);
-
+void kvm_vcpu_request_scan_ioapic(struct kvm *kvm);
+void kvm_ioapic_scan_entry(struct kvm_vcpu *vcpu, u64 *eoi_exit_bitmap,
+                        u32 *tmr);
 
 #endif
diff --git a/virt/kvm/irq_comm.c b/virt/kvm/irq_comm.c
index e9073cf4d040..25ab48007adb 100644
--- a/virt/kvm/irq_comm.c
+++ b/virt/kvm/irq_comm.c
@@ -35,7 +35,8 @@
 #include "ioapic.h"
 
 static int kvm_set_pic_irq(struct kvm_kernel_irq_routing_entry *e,
-                           struct kvm *kvm, int irq_source_id, int level)
+                           struct kvm *kvm, int irq_source_id, int level,
+                           bool line_status)
 {
 #ifdef CONFIG_X86
         struct kvm_pic *pic = pic_irqchip(kvm);
@@ -46,10 +47,12 @@ static int kvm_set_pic_irq(struct kvm_kernel_irq_routing_entry *e,
 }
 
 static int kvm_set_ioapic_irq(struct kvm_kernel_irq_routing_entry *e,
-                              struct kvm *kvm, int irq_source_id, int level)
+                              struct kvm *kvm, int irq_source_id, int level,
+                              bool line_status)
 {
         struct kvm_ioapic *ioapic = kvm->arch.vioapic;
-        return kvm_ioapic_set_irq(ioapic, e->irqchip.pin, irq_source_id, level);
+        return kvm_ioapic_set_irq(ioapic, e->irqchip.pin, irq_source_id, level,
+                                line_status);
 }
 
 inline static bool kvm_is_dm_lowest_prio(struct kvm_lapic_irq *irq)
@@ -63,7 +66,7 @@ inline static bool kvm_is_dm_lowest_prio(struct kvm_lapic_irq *irq)
 }
 
 int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
-                struct kvm_lapic_irq *irq)
+                struct kvm_lapic_irq *irq, unsigned long *dest_map)
 {
         int i, r = -1;
         struct kvm_vcpu *vcpu, *lowest = NULL;
@@ -74,7 +77,7 @@ int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
                 irq->delivery_mode = APIC_DM_FIXED;
         }
 
-        if (kvm_irq_delivery_to_apic_fast(kvm, src, irq, &r))
+        if (kvm_irq_delivery_to_apic_fast(kvm, src, irq, &r, dest_map))
                 return r;
 
         kvm_for_each_vcpu(i, vcpu, kvm) {
@@ -88,7 +91,7 @@ int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
                 if (!kvm_is_dm_lowest_prio(irq)) {
                         if (r < 0)
                                 r = 0;
-                        r += kvm_apic_set_irq(vcpu, irq);
+                        r += kvm_apic_set_irq(vcpu, irq, dest_map);
                 } else if (kvm_lapic_enabled(vcpu)) {
                         if (!lowest)
                                 lowest = vcpu;
@@ -98,7 +101,7 @@ int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
         }
 
         if (lowest)
-                r = kvm_apic_set_irq(lowest, irq);
+                r = kvm_apic_set_irq(lowest, irq, dest_map);
 
         return r;
 }
@@ -121,7 +124,7 @@ static inline void kvm_set_msi_irq(struct kvm_kernel_irq_routing_entry *e,
 }
 
 int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
-                struct kvm *kvm, int irq_source_id, int level)
+                struct kvm *kvm, int irq_source_id, int level, bool line_status)
 {
         struct kvm_lapic_irq irq;
 
@@ -130,7 +133,7 @@ int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
 
         kvm_set_msi_irq(e, &irq);
 
-        return kvm_irq_delivery_to_apic(kvm, NULL, &irq);
+        return kvm_irq_delivery_to_apic(kvm, NULL, &irq, NULL);
 }
 
 
@@ -142,7 +145,7 @@ static int kvm_set_msi_inatomic(struct kvm_kernel_irq_routing_entry *e,
 
         kvm_set_msi_irq(e, &irq);
 
-        if (kvm_irq_delivery_to_apic_fast(kvm, NULL, &irq, &r))
+        if (kvm_irq_delivery_to_apic_fast(kvm, NULL, &irq, &r, NULL))
                 return r;
         else
                 return -EWOULDBLOCK;
@@ -159,7 +162,7 @@ int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi)
         route.msi.address_hi = msi->address_hi;
         route.msi.data = msi->data;
 
-        return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1);
+        return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1, false);
 }
 
 /*
@@ -168,7 +171,8 @@ int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi)
  *  = 0   Interrupt was coalesced (previous irq is still pending)
  *  > 0   Number of CPUs interrupt was delivered to
  */
-int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level)
+int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
+                bool line_status)
 {
         struct kvm_kernel_irq_routing_entry *e, irq_set[KVM_NR_IRQCHIPS];
         int ret = -1, i = 0;
@@ -189,7 +193,8 @@ int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level)
 
         while(i--) {
                 int r;
-                r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level);
+                r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level,
+                                line_status);
                 if (r < 0)
                         continue;
 
@@ -280,7 +285,7 @@ void kvm_register_irq_ack_notifier(struct kvm *kvm,
         mutex_lock(&kvm->irq_lock);
         hlist_add_head_rcu(&kian->link, &kvm->irq_ack_notifier_list);
         mutex_unlock(&kvm->irq_lock);
-        kvm_ioapic_make_eoibitmap_request(kvm);
+        kvm_vcpu_request_scan_ioapic(kvm);
 }
 
 void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
@@ -290,7 +295,7 @@ void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
         hlist_del_init_rcu(&kian->link);
         mutex_unlock(&kvm->irq_lock);
         synchronize_rcu();
-        kvm_ioapic_make_eoibitmap_request(kvm);
+        kvm_vcpu_request_scan_ioapic(kvm);
 }
 
 int kvm_request_irq_source_id(struct kvm *kvm)
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index ff7154188b5f..aaac1a7a9ea8 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -217,9 +217,9 @@ void kvm_make_mclock_inprogress_request(struct kvm *kvm)
         make_all_cpus_request(kvm, KVM_REQ_MCLOCK_INPROGRESS);
 }
 
-void kvm_make_update_eoibitmap_request(struct kvm *kvm)
+void kvm_make_scan_ioapic_request(struct kvm *kvm)
 {
-        make_all_cpus_request(kvm, KVM_REQ_EOIBITMAP);
+        make_all_cpus_request(kvm, KVM_REQ_SCAN_IOAPIC);
 }
 
 int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id)
@@ -1078,7 +1078,7 @@ static int kvm_read_hva_atomic(void *data, void __user *hva, int len)
         return __copy_from_user_inatomic(data, hva, len);
 }
 
-int get_user_page_nowait(struct task_struct *tsk, struct mm_struct *mm,
+static int get_user_page_nowait(struct task_struct *tsk, struct mm_struct *mm,
         unsigned long start, int write, struct page **page)
 {
         int flags = FOLL_TOUCH | FOLL_NOWAIT | FOLL_HWPOISON | FOLL_GET;
@@ -1671,6 +1671,7 @@ void kvm_vcpu_kick(struct kvm_vcpu *vcpu)
                         smp_send_reschedule(cpu);
         put_cpu();
 }
+EXPORT_SYMBOL_GPL(kvm_vcpu_kick);
 #endif /* !CONFIG_S390 */
 
 void kvm_resched(struct kvm_vcpu *vcpu)
@@ -2258,7 +2259,8 @@ static long kvm_vm_ioctl(struct file *filp,
                 if (copy_from_user(&irq_event, argp, sizeof irq_event))
                         goto out;
 
-                r = kvm_vm_ioctl_irq_line(kvm, &irq_event);
+                r = kvm_vm_ioctl_irq_line(kvm, &irq_event,
+                                        ioctl == KVM_IRQ_LINE_STATUS);
                 if (r)
                         goto out;
 
@@ -2572,14 +2574,6 @@ static int kvm_cpu_hotplug(struct notifier_block *notifier, unsigned long val,
         return NOTIFY_OK;
 }
 
-
-asmlinkage void kvm_spurious_fault(void)
-{
-        /* Fault while not rebooting.  We want the trace. */
-        BUG();
-}
-EXPORT_SYMBOL_GPL(kvm_spurious_fault);
-
 static int kvm_reboot(struct notifier_block *notifier, unsigned long val,
                       void *v)
 {
@@ -2612,7 +2606,7 @@ static void kvm_io_bus_destroy(struct kvm_io_bus *bus)
         kfree(bus);
 }
 
-int kvm_io_bus_sort_cmp(const void *p1, const void *p2)
+static int kvm_io_bus_sort_cmp(const void *p1, const void *p2)
 {
         const struct kvm_io_range *r1 = p1;
         const struct kvm_io_range *r2 = p2;
@@ -2624,7 +2618,7 @@ int kvm_io_bus_sort_cmp(const void *p1, const void *p2)
         return 0;
 }
 
-int kvm_io_bus_insert_dev(struct kvm_io_bus *bus, struct kvm_io_device *dev,
+static int kvm_io_bus_insert_dev(struct kvm_io_bus *bus, struct kvm_io_device *dev,
                           gpa_t addr, int len)
 {
         bus->range[bus->dev_count++] = (struct kvm_io_range) {
@@ -2639,7 +2633,7 @@ int kvm_io_bus_insert_dev(struct kvm_io_bus *bus, struct kvm_io_device *dev,
         return 0;
 }
 
-int kvm_io_bus_get_first_dev(struct kvm_io_bus *bus,
+static int kvm_io_bus_get_first_dev(struct kvm_io_bus *bus,
                              gpa_t addr, int len)
 {
         struct kvm_io_range *range, key;