From: Sean Christopherson <seanjc@google.com>
To: Marc Zyngier <maz@kernel.org>,
Huacai Chen <chenhuacai@kernel.org>,
Aleksandar Markovic <aleksandar.qemu.devel@gmail.com>,
Paul Mackerras <paulus@ozlabs.org>,
Anup Patel <anup.patel@wdc.com>,
Paul Walmsley <paul.walmsley@sifive.com>,
Palmer Dabbelt <palmer@dabbelt.com>,
Albert Ou <aou@eecs.berkeley.edu>,
Christian Borntraeger <borntraeger@de.ibm.com>,
Janosch Frank <frankja@linux.ibm.com>,
Paolo Bonzini <pbonzini@redhat.com>
Cc: James Morse <james.morse@arm.com>,
Alexandru Elisei <alexandru.elisei@arm.com>,
Suzuki K Poulose <suzuki.poulose@arm.com>,
Atish Patra <atish.patra@wdc.com>,
David Hildenbrand <david@redhat.com>,
Cornelia Huck <cohuck@redhat.com>,
Claudio Imbrenda <imbrenda@linux.ibm.com>,
Sean Christopherson <seanjc@google.com>,
Vitaly Kuznetsov <vkuznets@redhat.com>,
Wanpeng Li <wanpengli@tencent.com>,
Jim Mattson <jmattson@google.com>,
Joerg Roedel <joro@8bytes.org>,
linux-arm-kernel@lists.infradead.org,
kvmarm@lists.cs.columbia.edu, linux-mips@vger.kernel.org,
kvm@vger.kernel.org, kvm-ppc@vger.kernel.org,
kvm-riscv@lists.infradead.org, linux-riscv@lists.infradead.org,
linux-kernel@vger.kernel.org,
David Matlack <dmatlack@google.com>,
Oliver Upton <oupton@google.com>,
Jing Zhang <jingzhangos@google.com>
Subject: [PATCH v2 29/43] KVM: VMX: Handle PI wakeup shenanigans during vcpu_put/load
Date: Fri, 8 Oct 2021 19:12:22 -0700 [thread overview]
Message-ID: <20211009021236.4122790-30-seanjc@google.com> (raw)
In-Reply-To: <20211009021236.4122790-1-seanjc@google.com>
Move the posted interrupt pre/post_block logic into vcpu_put/load
respectively, using the kvm_vcpu_is_blocking() to determining whether or
not the wakeup handler needs to be set (and unset). This avoids updating
the PI descriptor if halt-polling is successful, reduces the number of
touchpoints for updating the descriptor, and eliminates the confusing
behavior of intentionally leaving a "stale" PI.NDST when a blocking vCPU
is scheduled back in after preemption.
The downside is that KVM will do the PID update twice if the vCPU is
preempted after prepare_to_rcuwait() but before schedule(), but that's a
rare case (and non-existent on !PREEMPT kernels).
The notable wart is the need to send a self-IPI on the wakeup vector if
an outstanding notification is pending after configuring the wakeup
vector. Ideally, KVM would just do a kvm_vcpu_wake_up() in this case,
but the scheduler doesn't support waking a task from its preemption
notifier callback, i.e. while the task is smack dab in the middle of
being scheduled out.
Note, setting the wakeup vector before halt-polling is not necessary as
the pending IRQ will be recorded in the PIR and detected as a blocking-
breaking condition by kvm_vcpu_has_events() -> vmx_sync_pir_to_irr().
Signed-off-by: Sean Christopherson <seanjc@google.com>
---
arch/x86/kvm/vmx/posted_intr.c | 162 ++++++++++++++-------------------
arch/x86/kvm/vmx/posted_intr.h | 8 +-
arch/x86/kvm/vmx/vmx.c | 5 -
3 files changed, 75 insertions(+), 100 deletions(-)
diff --git a/arch/x86/kvm/vmx/posted_intr.c b/arch/x86/kvm/vmx/posted_intr.c
index 901b7a5f7777..d2b3d75c57d1 100644
--- a/arch/x86/kvm/vmx/posted_intr.c
+++ b/arch/x86/kvm/vmx/posted_intr.c
@@ -37,33 +37,45 @@ void vmx_vcpu_pi_load(struct kvm_vcpu *vcpu, int cpu)
{
struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
struct pi_desc old, new;
+ unsigned long flags;
unsigned int dest;
/*
- * To simplify hot-plug and dynamic toggling of APICv, keep PI.NDST and
- * PI.SN up-to-date even if there is no assigned device or if APICv is
+ * To simplify hot-plug and dynamic toggling of APICv, keep PI.NDST
+ * up-to-date even if there is no assigned device or if APICv is
* deactivated due to a dynamic inhibit bit, e.g. for Hyper-V's SyncIC.
*/
if (!enable_apicv || !lapic_in_kernel(vcpu))
return;
- /* Nothing to do if PI.SN==0 and the vCPU isn't being migrated. */
- if (!pi_test_sn(pi_desc) && vcpu->cpu == cpu)
+ /*
+ * If the vCPU wasn't on the wakeup list and wasn't migrated, then the
+ * full update can be skipped as neither the vector nor the destination
+ * needs to be changed.
+ */
+ if (pi_desc->nv != POSTED_INTR_WAKEUP_VECTOR && vcpu->cpu == cpu) {
+ /*
+ * Clear SN if it was set due to being preempted. Again, do
+ * this even if there is no assigned device for simplicity.
+ */
+ if (pi_test_and_clear_sn(pi_desc))
+ goto after_clear_sn;
return;
+ }
+
+ local_irq_save(flags);
/*
- * If the 'nv' field is POSTED_INTR_WAKEUP_VECTOR, do not change
- * PI.NDST: pi_post_block is the one expected to change PID.NDST and the
- * wakeup handler expects the vCPU to be on the blocked_vcpu_list that
- * matches PI.NDST. Otherwise, a vcpu may not be able to be woken up
- * correctly.
+ * If the vCPU was waiting for wakeup, remove the vCPU from the wakeup
+ * list of the _previous_ pCPU, which will not be the same as the
+ * current pCPU if the task was migrated.
*/
- if (pi_desc->nv == POSTED_INTR_WAKEUP_VECTOR || vcpu->cpu == cpu) {
- pi_clear_sn(pi_desc);
- goto after_clear_sn;
+ if (pi_desc->nv == POSTED_INTR_WAKEUP_VECTOR) {
+ spin_lock(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->cpu));
+ list_del(&vcpu->blocked_vcpu_list);
+ spin_unlock(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->cpu));
}
- /* The full case. Set the new destination and clear SN. */
dest = cpu_physical_id(cpu);
if (!x2apic_mode)
dest = (dest << 8) & 0xFF00;
@@ -71,11 +83,23 @@ void vmx_vcpu_pi_load(struct kvm_vcpu *vcpu, int cpu)
do {
old.control = new.control = READ_ONCE(pi_desc->control);
+ /*
+ * Clear SN (as above) and refresh the destination APIC ID to
+ * handle task migration (@cpu != vcpu->cpu).
+ */
new.ndst = dest;
new.sn = 0;
+
+ /*
+ * Restore the notification vector; in the blocking case, the
+ * descriptor was modified on "put" to use the wakeup vector.
+ */
+ new.nv = POSTED_INTR_VECTOR;
} while (cmpxchg64(&pi_desc->control, old.control,
new.control) != old.control);
+ local_irq_restore(flags);
+
after_clear_sn:
/*
@@ -90,88 +114,24 @@ void vmx_vcpu_pi_load(struct kvm_vcpu *vcpu, int cpu)
pi_set_on(pi_desc);
}
-void vmx_vcpu_pi_put(struct kvm_vcpu *vcpu)
-{
- struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
-
- if (!kvm_arch_has_assigned_device(vcpu->kvm) ||
- !irq_remapping_cap(IRQ_POSTING_CAP) ||
- !kvm_vcpu_apicv_active(vcpu))
- return;
-
- /* Set SN when the vCPU is preempted */
- if (vcpu->preempted)
- pi_set_sn(pi_desc);
-}
-
-static void __pi_post_block(struct kvm_vcpu *vcpu)
-{
- struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
- struct pi_desc old, new;
- unsigned int dest;
-
- WARN(pi_desc->nv != POSTED_INTR_WAKEUP_VECTOR,
- "Wakeup handler not enabled while the vCPU was blocking");
-
- /*
- * Remove the vCPU from the wakeup list of the _previous_ pCPU, which
- * will not be the same as the current pCPU if the task was migrated.
- */
- spin_lock(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu));
- list_del(&vcpu->blocked_vcpu_list);
- spin_unlock(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu));
-
- dest = cpu_physical_id(vcpu->cpu);
- if (!x2apic_mode)
- dest = (dest << 8) & 0xFF00;
-
- do {
- old.control = new.control = READ_ONCE(pi_desc->control);
-
- new.ndst = dest;
-
- /* set 'NV' to 'notification vector' */
- new.nv = POSTED_INTR_VECTOR;
- } while (cmpxchg64(&pi_desc->control, old.control,
- new.control) != old.control);
-
- vcpu->pre_pcpu = -1;
-}
-
/*
- * This routine does the following things for vCPU which is going
- * to be blocked if VT-d PI is enabled.
- * - Store the vCPU to the wakeup list, so when interrupts happen
- * we can find the right vCPU to wake up.
- * - Change the Posted-interrupt descriptor as below:
- * 'NV' <-- POSTED_INTR_WAKEUP_VECTOR
- * - If 'ON' is set during this process, which means at least one
- * interrupt is posted for this vCPU, we cannot block it, in
- * this case, return 1, otherwise, return 0.
- *
+ * Put the vCPU on this pCPU's list of vCPUs that needs to be awakened and set
+ * WAKEUP as the notification vector in the PI descriptor.
*/
-int pi_pre_block(struct kvm_vcpu *vcpu)
+static void pi_enable_wakeup_handler(struct kvm_vcpu *vcpu)
{
- struct pi_desc old, new;
struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
+ struct pi_desc old, new;
unsigned long flags;
- if (!kvm_arch_has_assigned_device(vcpu->kvm) ||
- !irq_remapping_cap(IRQ_POSTING_CAP) ||
- !kvm_vcpu_apicv_active(vcpu) ||
- vmx_interrupt_blocked(vcpu))
- return 0;
-
local_irq_save(flags);
- vcpu->pre_pcpu = vcpu->cpu;
spin_lock(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->cpu));
list_add_tail(&vcpu->blocked_vcpu_list,
&per_cpu(blocked_vcpu_on_cpu, vcpu->cpu));
spin_unlock(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->cpu));
- WARN(pi_desc->sn == 1,
- "Posted Interrupt Suppress Notification set before blocking");
+ WARN(pi_desc->sn, "PI descriptor SN field set before blocking");
do {
old.control = new.control = READ_ONCE(pi_desc->control);
@@ -181,24 +141,40 @@ int pi_pre_block(struct kvm_vcpu *vcpu)
} while (cmpxchg64(&pi_desc->control, old.control,
new.control) != old.control);
- /* We should not block the vCPU if an interrupt is posted for it. */
- if (pi_test_on(pi_desc))
- __pi_post_block(vcpu);
+ /*
+ * Send a wakeup IPI to this CPU if an interrupt may have been posted
+ * before the notification vector was updated, in which case the IRQ
+ * will arrive on the non-wakeup vector. An IPI is needed as calling
+ * try_to_wake_up() from ->sched_out() isn't allowed (IRQs are not
+ * enabled until it is safe to call try_to_wake_up() on the task being
+ * scheduled out).
+ */
+ if (pi_test_on(&new))
+ apic->send_IPI_self(POSTED_INTR_WAKEUP_VECTOR);
local_irq_restore(flags);
- return (vcpu->pre_pcpu == -1);
}
-void pi_post_block(struct kvm_vcpu *vcpu)
+void vmx_vcpu_pi_put(struct kvm_vcpu *vcpu)
{
- unsigned long flags;
+ struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
- if (vcpu->pre_pcpu == -1)
+ if (!kvm_arch_has_assigned_device(vcpu->kvm) ||
+ !irq_remapping_cap(IRQ_POSTING_CAP) ||
+ !kvm_vcpu_apicv_active(vcpu))
return;
- local_irq_save(flags);
- __pi_post_block(vcpu);
- local_irq_restore(flags);
+ if (kvm_vcpu_is_blocking(vcpu) && !vmx_interrupt_blocked(vcpu))
+ pi_enable_wakeup_handler(vcpu);
+
+ /*
+ * Set SN when the vCPU is preempted. Note, the vCPU can both be seen
+ * as blocking and preempted, e.g. if it's preempted between setting
+ * its wait state and manually scheduling out. In that case, KVM will
+ * update
+ */
+ if (vcpu->preempted)
+ pi_set_sn(pi_desc);
}
/*
@@ -239,7 +215,7 @@ bool pi_has_pending_interrupt(struct kvm_vcpu *vcpu)
* Bail out of the block loop if the VM has an assigned
* device, but the blocking vCPU didn't reconfigure the
* PI.NV to the wakeup vector, i.e. the assigned device
- * came along after the initial check in pi_pre_block().
+ * came along after the initial check in vmx_vcpu_pi_put().
*/
void vmx_pi_start_assignment(struct kvm *kvm)
{
diff --git a/arch/x86/kvm/vmx/posted_intr.h b/arch/x86/kvm/vmx/posted_intr.h
index 36ae035f14aa..eb14e76b84ef 100644
--- a/arch/x86/kvm/vmx/posted_intr.h
+++ b/arch/x86/kvm/vmx/posted_intr.h
@@ -40,6 +40,12 @@ static inline bool pi_test_and_clear_on(struct pi_desc *pi_desc)
(unsigned long *)&pi_desc->control);
}
+static inline bool pi_test_and_clear_sn(struct pi_desc *pi_desc)
+{
+ return test_and_clear_bit(POSTED_INTR_SN,
+ (unsigned long *)&pi_desc->control);
+}
+
static inline bool pi_test_and_set_pir(int vector, struct pi_desc *pi_desc)
{
return test_and_set_bit(vector, (unsigned long *)pi_desc->pir);
@@ -88,8 +94,6 @@ static inline bool pi_test_sn(struct pi_desc *pi_desc)
void vmx_vcpu_pi_load(struct kvm_vcpu *vcpu, int cpu);
void vmx_vcpu_pi_put(struct kvm_vcpu *vcpu);
-int pi_pre_block(struct kvm_vcpu *vcpu);
-void pi_post_block(struct kvm_vcpu *vcpu);
void pi_wakeup_handler(void);
void __init pi_init_cpu(int cpu);
bool pi_has_pending_interrupt(struct kvm_vcpu *vcpu);
diff --git a/arch/x86/kvm/vmx/vmx.c b/arch/x86/kvm/vmx/vmx.c
index 5517893f12fc..26ed8cd1a1f2 100644
--- a/arch/x86/kvm/vmx/vmx.c
+++ b/arch/x86/kvm/vmx/vmx.c
@@ -7462,9 +7462,6 @@ void vmx_update_cpu_dirty_logging(struct kvm_vcpu *vcpu)
static int vmx_pre_block(struct kvm_vcpu *vcpu)
{
- if (pi_pre_block(vcpu))
- return 1;
-
if (kvm_lapic_hv_timer_in_use(vcpu))
kvm_lapic_switch_to_sw_timer(vcpu);
@@ -7475,8 +7472,6 @@ static void vmx_post_block(struct kvm_vcpu *vcpu)
{
if (kvm_x86_ops.set_hv_timer)
kvm_lapic_switch_to_hv_timer(vcpu);
-
- pi_post_block(vcpu);
}
static void vmx_setup_mce(struct kvm_vcpu *vcpu)
--
2.33.0.882.g93a45727a2-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
next prev parent reply other threads:[~2021-10-09 2:45 UTC|newest]
Thread overview: 141+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-10-09 2:11 [PATCH v2 00/43] KVM: Halt-polling and x86 APICv overhaul Sean Christopherson
2021-10-09 2:11 ` [PATCH v2 01/43] KVM: VMX: Don't unblock vCPU w/ Posted IRQ if IRQs are disabled in guest Sean Christopherson
2021-10-09 2:11 ` [PATCH v2 02/43] KVM: SVM: Ensure target pCPU is read once when signalling AVIC doorbell Sean Christopherson
2021-10-25 13:21 ` Paolo Bonzini
2021-10-27 9:50 ` Maxim Levitsky
2021-10-09 2:11 ` [PATCH v2 03/43] KVM: s390: Ensure kvm_arch_no_poll() is read once when blocking vCPU Sean Christopherson
2021-10-09 2:11 ` [PATCH v2 04/43] KVM: Force PPC to define its own rcuwait object Sean Christopherson
2021-10-09 2:11 ` [PATCH v2 05/43] KVM: Update halt-polling stats if and only if halt-polling was attempted Sean Christopherson
2021-10-27 10:18 ` Maxim Levitsky
2021-10-09 2:11 ` [PATCH v2 06/43] KVM: Refactor and document halt-polling stats update helper Sean Christopherson
2021-10-27 10:56 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 07/43] KVM: Reconcile discrepancies in halt-polling stats Sean Christopherson
2021-10-27 11:29 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 08/43] KVM: s390: Clear valid_wakeup in kvm_s390_handle_wait(), not in arch hook Sean Christopherson
2021-10-09 2:12 ` [PATCH v2 09/43] KVM: Drop obsolete kvm_arch_vcpu_block_finish() Sean Christopherson
2021-10-22 15:02 ` Anup Patel
2021-10-09 2:12 ` [PATCH v2 10/43] KVM: arm64: Move vGIC v4 handling for WFI out arch callback hook Sean Christopherson
2021-10-25 13:31 ` Paolo Bonzini
2021-10-26 15:41 ` Marc Zyngier
2021-10-26 16:12 ` Paolo Bonzini
2021-11-30 11:39 ` Paolo Bonzini
2021-11-30 12:04 ` Marc Zyngier
2021-11-30 16:07 ` Paolo Bonzini
2021-10-09 2:12 ` [PATCH v2 11/43] KVM: Don't block+unblock when halt-polling is successful Sean Christopherson
2021-10-27 13:40 ` Maxim Levitsky
2021-11-28 22:16 ` Maxim Levitsky
2021-11-29 17:25 ` Sean Christopherson
2021-11-29 17:53 ` Paolo Bonzini
2021-11-29 18:55 ` Sean Christopherson
2021-11-29 19:18 ` Paolo Bonzini
2021-11-29 22:53 ` Maxim Levitsky
2021-12-02 0:20 ` Maxim Levitsky
2021-12-02 2:00 ` Sean Christopherson
2021-12-02 10:31 ` Paolo Bonzini
2021-11-29 17:55 ` Paolo Bonzini
2021-11-29 22:55 ` Maxim Levitsky
2021-12-02 10:20 ` Maxim Levitsky
2021-12-02 10:47 ` Maxim Levitsky
2021-12-02 12:02 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 12/43] KVM: x86: Tweak halt emulation helper names to free up kvm_vcpu_halt() Sean Christopherson
2021-10-27 14:10 ` Maxim Levitsky
2021-10-27 14:18 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 13/43] KVM: Rename kvm_vcpu_block() => kvm_vcpu_halt() Sean Christopherson
2021-10-22 15:04 ` Anup Patel
2021-10-09 2:12 ` [PATCH v2 14/43] KVM: Split out a kvm_vcpu_block() helper from kvm_vcpu_halt() Sean Christopherson
2021-10-09 2:12 ` [PATCH v2 15/43] KVM: stats: Add stat to detect if vcpu is currently blocking Sean Christopherson
2021-10-09 2:12 ` [PATCH v2 16/43] KVM: Don't redo ktime_get() when calculating halt-polling stop/deadline Sean Christopherson
2021-10-25 14:26 ` Paolo Bonzini
2021-10-27 14:35 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 17/43] KVM: x86: Directly block (instead of "halting") UNINITIALIZED vCPUs Sean Christopherson
2021-10-27 14:46 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 18/43] KVM: x86: Invoke kvm_vcpu_block() directly for non-HALTED wait states Sean Christopherson
2021-10-27 15:18 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 19/43] KVM: Add helpers to wake/query blocking vCPU Sean Christopherson
2021-10-25 14:06 ` Paolo Bonzini
2021-10-27 19:27 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 20/43] KVM: VMX: Skip Posted Interrupt updates if APICv is hard disabled Sean Christopherson
2021-10-25 13:48 ` Paolo Bonzini
2021-10-28 9:12 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 21/43] KVM: VMX: Clean up PI pre/post-block WARNs Sean Christopherson
2021-10-28 10:20 ` Maxim Levitsky
2021-10-28 15:34 ` Sean Christopherson
2021-10-09 2:12 ` [PATCH v2 22/43] KVM: VMX: Drop unnecessary PI logic to handle impossible conditions Sean Christopherson
2021-10-25 13:53 ` Paolo Bonzini
2021-10-28 14:36 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 23/43] KVM: VMX: Use boolean returns for Posted Interrupt "test" helpers Sean Christopherson
2021-10-28 6:05 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 24/43] KVM: VMX: Drop pointless PI.NDST update when blocking Sean Christopherson
2021-10-25 14:01 ` Paolo Bonzini
2021-10-27 14:26 ` Sean Christopherson
2021-10-28 10:53 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 25/43] KVM: VMX: Save/restore IRQs (instead of CLI/STI) during PI pre/post block Sean Christopherson
2021-10-28 10:54 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 26/43] KVM: VMX: Read Posted Interrupt "control" exactly once per loop iteration Sean Christopherson
2021-10-28 10:58 ` Maxim Levitsky
2021-10-28 15:55 ` Sean Christopherson
2021-10-31 22:48 ` Maxim Levitsky
2021-11-01 17:41 ` Sean Christopherson
2021-10-09 2:12 ` [PATCH v2 27/43] KVM: VMX: Move Posted Interrupt ndst computation out of write loop Sean Christopherson
2021-10-28 11:28 ` Maxim Levitsky
2021-10-28 16:09 ` Maxim Levitsky
2021-10-28 16:12 ` Sean Christopherson
2021-10-31 22:51 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 28/43] KVM: VMX: Remove vCPU from PI wakeup list before updating PID.NV Sean Christopherson
2021-10-28 12:53 ` Maxim Levitsky
2021-10-28 17:19 ` Sean Christopherson
2021-10-31 22:52 ` Maxim Levitsky
2021-10-09 2:12 ` Sean Christopherson [this message]
2021-10-28 15:14 ` [PATCH v2 29/43] KVM: VMX: Handle PI wakeup shenanigans during vcpu_put/load Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 30/43] KVM: Drop unused kvm_vcpu.pre_pcpu field Sean Christopherson
2021-10-28 15:16 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 31/43] KVM: Move x86 VMX's posted interrupt list_head to vcpu_vmx Sean Christopherson
2021-10-28 15:33 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 32/43] KVM: VMX: Move preemption timer <=> hrtimer dance to common x86 Sean Christopherson
2021-10-28 15:45 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 33/43] KVM: x86: Unexport LAPIC's switch_to_{hv, sw}_timer() helpers Sean Christopherson
2021-10-28 15:45 ` [PATCH v2 33/43] KVM: x86: Unexport LAPIC's switch_to_{hv,sw}_timer() helpers Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 34/43] KVM: x86: Remove defunct pre_block/post_block kvm_x86_ops hooks Sean Christopherson
2021-10-28 15:46 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 35/43] KVM: SVM: Signal AVIC doorbell iff vCPU is in guest mode Sean Christopherson
2021-10-25 14:26 ` Paolo Bonzini
2021-10-27 15:06 ` Sean Christopherson
2021-10-27 15:36 ` Paolo Bonzini
2021-10-27 16:08 ` Sean Christopherson
2021-10-27 16:14 ` Paolo Bonzini
2021-10-28 16:12 ` Maxim Levitsky
2021-10-28 17:06 ` Sean Christopherson
2021-10-09 2:12 ` [PATCH v2 36/43] KVM: SVM: Don't bother checking for "running" AVIC when kicking for IPIs Sean Christopherson
2021-10-31 14:50 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 37/43] KVM: SVM: Unconditionally mark AVIC as running on vCPU load (with APICv) Sean Christopherson
2021-10-25 14:22 ` Paolo Bonzini
2021-10-25 15:48 ` Sean Christopherson
2021-10-25 15:57 ` Paolo Bonzini
2021-10-25 16:00 ` Sean Christopherson
2021-10-31 16:34 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 38/43] KVM: Drop defunct kvm_arch_vcpu_(un)blocking() hooks Sean Christopherson
2021-10-31 16:35 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 39/43] KVM: VMX: Don't do full kick when triggering posted interrupt "fails" Sean Christopherson
2021-10-25 14:34 ` Paolo Bonzini
2021-10-27 16:04 ` Sean Christopherson
2021-10-27 22:09 ` Paolo Bonzini
2021-10-31 22:15 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 40/43] KVM: VMX: Wake vCPU when delivering posted IRQ even if vCPU == this vCPU Sean Christopherson
2021-10-25 15:05 ` Paolo Bonzini
2021-10-27 15:30 ` Sean Christopherson
2021-10-31 22:19 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 41/43] KVM: VMX: Pass desired vector instead of bool for triggering posted IRQ Sean Christopherson
2021-10-31 22:25 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 42/43] KVM: VMX: Fold fallback path into triggering posted IRQ helper Sean Christopherson
2021-10-31 22:30 ` Maxim Levitsky
2021-10-09 2:12 ` [PATCH v2 43/43] KVM: VMX: Don't do full kick when handling posted interrupt wakeup Sean Christopherson
2021-10-25 14:16 ` Paolo Bonzini
2021-10-31 22:33 ` Maxim Levitsky
2021-10-25 14:13 ` [PATCH v2 00/43] KVM: Halt-polling and x86 APICv overhaul Paolo Bonzini
2021-10-27 14:41 ` Sean Christopherson
2021-10-27 14:57 ` Paolo Bonzini
2021-10-27 15:28 ` Sean Christopherson
2021-10-27 15:37 ` Paolo Bonzini
2021-10-26 7:20 ` Christian Borntraeger
2021-10-26 14:48 ` Sean Christopherson
2021-10-26 18:29 ` Christian Borntraeger
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20211009021236.4122790-30-seanjc@google.com \
--to=seanjc@google.com \
--cc=aleksandar.qemu.devel@gmail.com \
--cc=alexandru.elisei@arm.com \
--cc=anup.patel@wdc.com \
--cc=aou@eecs.berkeley.edu \
--cc=atish.patra@wdc.com \
--cc=borntraeger@de.ibm.com \
--cc=chenhuacai@kernel.org \
--cc=cohuck@redhat.com \
--cc=david@redhat.com \
--cc=dmatlack@google.com \
--cc=frankja@linux.ibm.com \
--cc=imbrenda@linux.ibm.com \
--cc=james.morse@arm.com \
--cc=jingzhangos@google.com \
--cc=jmattson@google.com \
--cc=joro@8bytes.org \
--cc=kvm-ppc@vger.kernel.org \
--cc=kvm-riscv@lists.infradead.org \
--cc=kvm@vger.kernel.org \
--cc=kvmarm@lists.cs.columbia.edu \
--cc=linux-arm-kernel@lists.infradead.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mips@vger.kernel.org \
--cc=linux-riscv@lists.infradead.org \
--cc=maz@kernel.org \
--cc=oupton@google.com \
--cc=palmer@dabbelt.com \
--cc=paul.walmsley@sifive.com \
--cc=paulus@ozlabs.org \
--cc=pbonzini@redhat.com \
--cc=suzuki.poulose@arm.com \
--cc=vkuznets@redhat.com \
--cc=wanpengli@tencent.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).