Linux kernel -stable discussions
 help / color / mirror / Atom feed
* [PATCH v2 1/2] KVM: Stop KVM_PRE_FAULT_MEMORY when the vCPU's dirty ring is full
       [not found] <20261117074428.7544-1-fuad.tabba@linux.dev>
@ 2026-11-17  7:44 ` Fuad Tabba
  2026-11-17 14:23   ` Lorenzo Stoakes (ARM)
  0 siblings, 1 reply; 4+ messages in thread
From: Fuad Tabba @ 2026-11-17  7:44 UTC (permalink / raw)
  To: Paolo Bonzini, Sean Christopherson
  Cc: kvm, linux-kselftest, linux-doc, linux-kernel, Jonathan Corbet,
	Shuah Khan, Isaku Yamahata, Rick Edgecombe, Lorenzo Stoakes,
	Alexandru Elisei, Marc Zyngier, Oliver Upton, kvmarm,
	Wei-Lin Chang, Will Deacon, Fuad Tabba, stable

Pre-faulting can map a dirty-logged page writable, which pushes it to
the vCPU's dirty ring. KVM_RUN exits with KVM_EXIT_DIRTY_RING_FULL
before the ring overflows, but the pre-fault loop never checks it, so
one call can push more entries than the ring has free, which trips the
WARN in kvm_dirty_ring_push() and overwrites entries userspace hasn't
harvested. On x86:

  WARNING: arch/x86/kvm/../../../virt/kvm/dirty_ring.c:225 at kvm_dirty_ring_push+0x7a/0xd0
  Call Trace:
   make_spte+0x2cc/0x450
   kvm_tdp_mmu_map+0x5e1/0x7f0
   kvm_tdp_page_fault+0x12c/0x1b0
   kvm_mmu_do_page_fault+0x181/0x250
   kvm_arch_vcpu_pre_fault_memory+0x136/0x1d0
   kvm_vcpu_pre_fault_memory+0xcf/0x180
   kvm_vcpu_ioctl+0x455/0x770

Stop the loop once the ring is soft full, with the check KVM_RUN makes
before entering the guest. Return the pages already processed, or
-ENOSPC when there aren't any, since a retry can't succeed until
userspace harvests and resets the ring. s390 has the ioctl but no ring,
so give kvm_dirty_ring_check_request() a stub.

The check also sets run->exit_reason, and arm64's KVM_RUN completes a
pending MMIO exit only if exit_reason is still KVM_EXIT_MMIO. If a
pre-fault stops on a full ring while an MMIO exit is pending, the next
KVM_RUN doesn't complete the exit and the guest repeats the MMIO
access. Userspace can avoid that by completing the exit with KVM_RUN
before it pre-faults.

Fixes: bc1a5cd002116 ("KVM: Add KVM_PRE_FAULT_MEMORY vcpu ioctl to pre-populate guest memory")
Cc: stable@vger.kernel.org
Signed-off-by: Fuad Tabba <fuad.tabba@linux.dev>
---
 Documentation/virt/kvm/api.rst | 9 +++++++--
 include/linux/kvm_dirty_ring.h | 5 +++++
 virt/kvm/kvm_main.c            | 5 +++++
 3 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst
index e95c9cda085d9..89eb6be9bc6e3 100644
--- a/Documentation/virt/kvm/api.rst
+++ b/Documentation/virt/kvm/api.rst
@@ -6544,6 +6544,7 @@ Errors:
   ENOENT     The specified `gpa` is outside defined memslots.
   ENOEXEC    The vCPU has not been initialised (arm64).
   EINTR      An unmasked signal is pending and no page was processed.
+  ENOSPC     The vCPU's dirty ring is full and no page was processed.
   EFAULT     The parameter address was invalid.
   EHWPOISON  A poisoned host page was encountered.
   EOPNOTSUPP Mapping memory for a GPA is unsupported by the
@@ -6588,7 +6589,9 @@ case, the ioctl can be called in parallel.
 
 When the ioctl returns, the input values are updated to point to the
 remaining range.  If `size` > 0 on return, the caller can just issue
-the ioctl again with the same `struct kvm_map_memory` argument.
+the ioctl again with the same `struct kvm_pre_fault_memory` argument.
+If that fails with ENOSPC, the vCPU's dirty ring has to be harvested
+and reset first.
 
 On x86, shadow page tables cannot support this ioctl because they
 are indexed by virtual address or nested guest physical address.
@@ -8957,7 +8960,9 @@ Therefore, the ioctl must be called *before* reading the content of
 the dirty pages.
 
 The dirty ring can get full.  When it happens, the KVM_RUN of the
-vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL.
+vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL, and
+KVM_PRE_FAULT_MEMORY on the vcpu will process no more pages until the
+ring has been harvested and reset.
 
 The dirty ring interface has a major difference comparing to the
 KVM_GET_DIRTY_LOG interface in that, when reading the dirty ring from
diff --git a/include/linux/kvm_dirty_ring.h b/include/linux/kvm_dirty_ring.h
index eb10d87adf7d5..729615ae0cf4d 100644
--- a/include/linux/kvm_dirty_ring.h
+++ b/include/linux/kvm_dirty_ring.h
@@ -60,6 +60,11 @@ static inline void kvm_dirty_ring_push(struct kvm_vcpu *vcpu,
 {
 }
 
+static inline bool kvm_dirty_ring_check_request(struct kvm_vcpu *vcpu)
+{
+	return false;
+}
+
 static inline struct page *kvm_dirty_ring_get_page(struct kvm_dirty_ring *ring,
 						   u32 offset)
 {
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index cf4cb586f1407..ac8b94a386e4a 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -4461,6 +4461,11 @@ static int kvm_vcpu_pre_fault_memory(struct kvm_vcpu *vcpu,
 			break;
 		}
 
+		if (kvm_dirty_ring_check_request(vcpu)) {
+			r = -ENOSPC;
+			break;
+		}
+
 		r = kvm_arch_vcpu_pre_fault_memory(vcpu, range);
 		if (WARN_ON_ONCE(r == 0 || r == -EIO))
 			break;
-- 
2.47.3


^ permalink raw reply related	[flat|nested] 4+ messages in thread

* Re: [PATCH v2 1/2] KVM: Stop KVM_PRE_FAULT_MEMORY when the vCPU's dirty ring is full
  2026-11-17  7:44 ` [PATCH v2 1/2] KVM: Stop KVM_PRE_FAULT_MEMORY when the vCPU's dirty ring is full Fuad Tabba
@ 2026-11-17 14:23   ` Lorenzo Stoakes (ARM)
  2026-11-17 17:05     ` Fuad Tabba
  0 siblings, 1 reply; 4+ messages in thread
From: Lorenzo Stoakes (ARM) @ 2026-11-17 14:23 UTC (permalink / raw)
  To: Fuad Tabba
  Cc: Paolo Bonzini, Sean Christopherson, kvm, linux-kselftest,
	linux-doc, linux-kernel, Jonathan Corbet, Shuah Khan,
	Isaku Yamahata, Rick Edgecombe, Alexandru Elisei, Marc Zyngier,
	Oliver Upton, kvmarm, Wei-Lin Chang, Will Deacon, Fuad Tabba,
	stable

On Tue, Nov 17, 2026 at 07:44:27AM +0000, Fuad Tabba wrote:
> Pre-faulting can map a dirty-logged page writable, which pushes it to
> the vCPU's dirty ring. KVM_RUN exits with KVM_EXIT_DIRTY_RING_FULL
> before the ring overflows, but the pre-fault loop never checks it, so
> one call can push more entries than the ring has free, which trips the
> WARN in kvm_dirty_ring_push() and overwrites entries userspace hasn't
> harvested. On x86:
>
>   WARNING: arch/x86/kvm/../../../virt/kvm/dirty_ring.c:225 at kvm_dirty_ring_push+0x7a/0xd0
>   Call Trace:
>    make_spte+0x2cc/0x450
>    kvm_tdp_mmu_map+0x5e1/0x7f0
>    kvm_tdp_page_fault+0x12c/0x1b0
>    kvm_mmu_do_page_fault+0x181/0x250
>    kvm_arch_vcpu_pre_fault_memory+0x136/0x1d0
>    kvm_vcpu_pre_fault_memory+0xcf/0x180
>    kvm_vcpu_ioctl+0x455/0x770
>
> Stop the loop once the ring is soft full, with the check KVM_RUN makes
> before entering the guest. Return the pages already processed, or
> -ENOSPC when there aren't any, since a retry can't succeed until
> userspace harvests and resets the ring. s390 has the ioctl but no ring,
> so give kvm_dirty_ring_check_request() a stub.
>
> The check also sets run->exit_reason, and arm64's KVM_RUN completes a
> pending MMIO exit only if exit_reason is still KVM_EXIT_MMIO. If a
> pre-fault stops on a full ring while an MMIO exit is pending, the next
> KVM_RUN doesn't complete the exit and the guest repeats the MMIO
> access. Userspace can avoid that by completing the exit with KVM_RUN
> before it pre-faults.

That's also true for riscv:

	switch (run->exit_reason) {
	case KVM_EXIT_MMIO:
		/* Process MMIO value returned from user-space */
		ret = kvm_riscv_vcpu_mmio_return(vcpu, vcpu->run);
		break;
	case KVM_EXIT_RISCV_SBI:
		/* Process SBI value returned from user-space */
		ret = kvm_riscv_vcpu_sbi_return(vcpu, vcpu->run);
		break;
	case KVM_EXIT_RISCV_CSR:
		/* Process CSR value returned from user-space */
		ret = kvm_riscv_vcpu_csr_return(vcpu, vcpu->run);
		break;
	}

(note that it skips CSR, SBI also with a changed exit_reason).

But the overflow bug only applies to x86 (see below), so is this something
we should worry about at all?


>
> Fixes: bc1a5cd002116 ("KVM: Add KVM_PRE_FAULT_MEMORY vcpu ioctl to pre-populate guest memory")
> Cc: stable@vger.kernel.org
> Signed-off-by: Fuad Tabba <fuad.tabba@linux.dev>
> ---
>  Documentation/virt/kvm/api.rst | 9 +++++++--
>  include/linux/kvm_dirty_ring.h | 5 +++++
>  virt/kvm/kvm_main.c            | 5 +++++
>  3 files changed, 17 insertions(+), 2 deletions(-)
>
> diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst
> index e95c9cda085d9..89eb6be9bc6e3 100644
> --- a/Documentation/virt/kvm/api.rst
> +++ b/Documentation/virt/kvm/api.rst
> @@ -6544,6 +6544,7 @@ Errors:
>    ENOENT     The specified `gpa` is outside defined memslots.
>    ENOEXEC    The vCPU has not been initialised (arm64).
>    EINTR      An unmasked signal is pending and no page was processed.
> +  ENOSPC     The vCPU's dirty ring is full and no page was processed.
>    EFAULT     The parameter address was invalid.
>    EHWPOISON  A poisoned host page was encountered.
>    EOPNOTSUPP Mapping memory for a GPA is unsupported by the
> @@ -6588,7 +6589,9 @@ case, the ioctl can be called in parallel.
>
>  When the ioctl returns, the input values are updated to point to the
>  remaining range.  If `size` > 0 on return, the caller can just issue
> -the ioctl again with the same `struct kvm_map_memory` argument.
> +the ioctl again with the same `struct kvm_pre_fault_memory` argument.
> +If that fails with ENOSPC, the vCPU's dirty ring has to be harvested
> +and reset first.
>
>  On x86, shadow page tables cannot support this ioctl because they
>  are indexed by virtual address or nested guest physical address.
> @@ -8957,7 +8960,9 @@ Therefore, the ioctl must be called *before* reading the content of
>  the dirty pages.
>
>  The dirty ring can get full.  When it happens, the KVM_RUN of the
> -vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL.
> +vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL, and
> +KVM_PRE_FAULT_MEMORY on the vcpu will process no more pages until the
> +ring has been harvested and reset.

Maybe worth mentioning the exit_reason thing if we keep this arch-generic?

>
>  The dirty ring interface has a major difference comparing to the
>  KVM_GET_DIRTY_LOG interface in that, when reading the dirty ring from
> diff --git a/include/linux/kvm_dirty_ring.h b/include/linux/kvm_dirty_ring.h
> index eb10d87adf7d5..729615ae0cf4d 100644
> --- a/include/linux/kvm_dirty_ring.h
> +++ b/include/linux/kvm_dirty_ring.h
> @@ -60,6 +60,11 @@ static inline void kvm_dirty_ring_push(struct kvm_vcpu *vcpu,
>  {
>  }
>
> +static inline bool kvm_dirty_ring_check_request(struct kvm_vcpu *vcpu)
> +{
> +	return false;
> +}
> +
>  static inline struct page *kvm_dirty_ring_get_page(struct kvm_dirty_ring *ring,
>  						   u32 offset)
>  {
> diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
> index cf4cb586f1407..ac8b94a386e4a 100644
> --- a/virt/kvm/kvm_main.c
> +++ b/virt/kvm/kvm_main.c
> @@ -4461,6 +4461,11 @@ static int kvm_vcpu_pre_fault_memory(struct kvm_vcpu *vcpu,
>  			break;
>  		}
>
> +		if (kvm_dirty_ring_check_request(vcpu)) {
> +			r = -ENOSPC;
> +			break;
> +		}
> +
>  		r = kvm_arch_vcpu_pre_fault_memory(vcpu, range);
>  		if (WARN_ON_ONCE(r == 0 || r == -EIO))
>  			break;
> --
> 2.47.3
>

I wonder if this shouldn't just be an x86-only fix, since no other arch is
impacted AFAICT.

arm64 and riscv never map a dirty-logged memslot writable, so they're never
pushed to the rin, and s390 doesn't have a dirty ring at all:

arm64:

static int kvm_s2_fault_compute_prot(const struct kvm_s2_fault_desc *s2fd,
				     const struct kvm_s2_fault_vma_info *s2vi,
				     enum kvm_pgtable_prot *prot)
{
	...
	if (s2vi->map_writable && (s2vi->device ||
				   !memslot_is_logging(s2fd->memslot) ||
				   kvm_s2_fault_is_write(s2fd)))
		*prot |= KVM_PGTABLE_PROT_W;
	...
}

riscv:

int kvm_riscv_mmu_map(struct kvm_vcpu *vcpu, struct kvm_memory_slot *memslot,
		      gpa_t gpa, unsigned long hva, bool is_write,
		      struct kvm_gstage_mapping *out_map)
{
	...
	bool logging = kvm_slot_dirty_track_enabled(memslot) &&
		       !(memslot->flags & KVM_MEM_READONLY);
	...
	/*
	 * If logging is active then we allow writable pages only
	 * for write faults.
	 */
	if (logging && !is_write)
		writable = false;
	...
}

An x86-only version would be pretty simple, something like the below.

This also covers off the retry (RET_PF_RETRY) loop which a generic version
doesn't.

diff --git a/arch/x86/kvm/mmu/mmu.c b/arch/x86/kvm/mmu/mmu.c
index f89e9f8a6cc2..343eb5ad0baa 100644
--- a/arch/x86/kvm/mmu/mmu.c
+++ b/arch/x86/kvm/mmu/mmu.c
@@ -5129,6 +5129,14 @@ static int kvm_tdp_page_prefault(struct kvm_vcpu *vcpu, gpa_t gpa,
 		if (kvm_test_request(KVM_REQ_VM_DEAD, vcpu))
 			return -EIO;

+		if (kvm_dirty_ring_check_request(vcpu))
+			return -ENOSPC;
+
 		r = kvm_mmu_reload(vcpu);
 		if (r)
 			return r;


--
Cheers, Lorenzo

^ permalink raw reply related	[flat|nested] 4+ messages in thread

* Re: [PATCH v2 1/2] KVM: Stop KVM_PRE_FAULT_MEMORY when the vCPU's dirty ring is full
  2026-11-17 14:23   ` Lorenzo Stoakes (ARM)
@ 2026-11-17 17:05     ` Fuad Tabba
  2026-11-19  0:25       ` Sean Christopherson
  0 siblings, 1 reply; 4+ messages in thread
From: Fuad Tabba @ 2026-11-17 17:05 UTC (permalink / raw)
  To: Lorenzo Stoakes (ARM)
  Cc: Paolo Bonzini, Sean Christopherson, kvm, linux-kselftest,
	linux-doc, linux-kernel, Jonathan Corbet, Shuah Khan,
	Isaku Yamahata, Rick Edgecombe, Alexandru Elisei, Marc Zyngier,
	Oliver Upton, kvmarm, Wei-Lin Chang, Will Deacon, stable

Hi Lorenzo,

On Tue, 17 Nov 2026 14:23:09 +0000, "Lorenzo Stoakes (ARM)"
<ljs@kernel.org> wrote:
[...]
> > The check also sets run->exit_reason, and arm64's KVM_RUN completes a
> > pending MMIO exit only if exit_reason is still KVM_EXIT_MMIO. If a
> > pre-fault stops on a full ring while an MMIO exit is pending, the next
> > KVM_RUN doesn't complete the exit and the guest repeats the MMIO
> > access. Userspace can avoid that by completing the exit with KVM_RUN
> > before it pre-faults.
>
> That's also true for riscv:
>
>         switch (run->exit_reason) {
>         case KVM_EXIT_MMIO:
>                 /* Process MMIO value returned from user-space */
>                 ret = kvm_riscv_vcpu_mmio_return(vcpu, vcpu->run);
>                 break;
>         case KVM_EXIT_RISCV_SBI:
>                 /* Process SBI value returned from user-space */
>                 ret = kvm_riscv_vcpu_sbi_return(vcpu, vcpu->run);
>                 break;
>         case KVM_EXIT_RISCV_CSR:
>                 /* Process CSR value returned from user-space */
>                 ret = kvm_riscv_vcpu_csr_return(vcpu, vcpu->run);
>                 break;
>         }
>
> (note that it skips CSR, SBI also with a changed exit_reason).

Ack.

> But the overflow bug only applies to x86 (see below), so is this something
> we should worry about at all?

The ring overflows on arm64 too (below). As for exit_reason, I asked
Sean about the arm64 MMIO case on v1, and his answer was that a VMM
that pre-faults between a KVM_EXIT_MMIO return and the next KVM_RUN
"gets to deal with the fallout" [1]. I think the same goes for riscv's
exits.

[...]
> > diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst
[...]
> >  The dirty ring can get full.  When it happens, the KVM_RUN of the
> > -vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL.
> > +vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL, and
> > +KVM_PRE_FAULT_MEMORY on the vcpu will process no more pages until the
> > +ring has been harvested and reset.
>
> Maybe worth mentioning the exit_reason thing if we keep this arch-generic?

Sure, I'll document that userspace should complete a pending exit with
KVM_RUN before it pre-faults on that vCPU.

[...]
> I wonder if this shouldn't just be an x86-only fix, since no other arch is
> impacted AFAICT.
>
> arm64 and riscv never map a dirty-logged memslot writable, so they're never
> pushed to the rin, and s390 doesn't have a dirty ring at all:
>
> arm64:
>
> static int kvm_s2_fault_compute_prot(const struct kvm_s2_fault_desc *s2fd,
>                                      const struct kvm_s2_fault_vma_info *s2vi,
>                                      enum kvm_pgtable_prot *prot)
> {
>         ...
>         if (s2vi->map_writable && (s2vi->device ||
>                                    !memslot_is_logging(s2fd->memslot) ||
>                                    kvm_s2_fault_is_write(s2fd)))
>                 *prot |= KVM_PGTABLE_PROT_W;
>         ...
> }

arm64 does map a logged slot as writable today. memslot_is_logging()
tests memslot->dirty_bitmap, which isn't allocated when only the dirty
ring is enabled, and patch 2's selftest triggers the WARN in
kvm_dirty_ring_push() on arm64 without patch 1. Wei-Lin's fix to
memslot_is_logging() [2] is in kvmarm/fixes, not in mainline yet.

With it, the s2vi->device case above still maps a device page writable
on a read fault in a logged slot. kvm_arch_prepare_memory_region()
rejects logging on a VM_PFNMAP VMA, so that requires userspace to map
the device under the slot after creating it (I haven't tested it).

So I think the check should be in the generic loop.

[...]
> An x86-only version would be pretty simple, something like the below.
>
> This also covers off the retry (RET_PF_RETRY) loop which a generic version
> doesn't.

True. To overflow there, the retries for one page would have to push
more entries than the ring has in reserve (at least 64), and I don't
see a way to get that, so I left it alone.

Cheers,
/fuad

[1] https://lore.kernel.org/all/avs5UD79FB_DG1Vs@seanjc-mac.roam.internal/
[2] https://lore.kernel.org/all/20261029175238.3214788-2-weilin.chang@arm.com/

^ permalink raw reply	[flat|nested] 4+ messages in thread

* Re: [PATCH v2 1/2] KVM: Stop KVM_PRE_FAULT_MEMORY when the vCPU's dirty ring is full
  2026-11-17 17:05     ` Fuad Tabba
@ 2026-11-19  0:25       ` Sean Christopherson
  0 siblings, 0 replies; 4+ messages in thread
From: Sean Christopherson @ 2026-11-19  0:25 UTC (permalink / raw)
  To: Fuad Tabba
  Cc: Lorenzo Stoakes (ARM), Paolo Bonzini, kvm, linux-kselftest,
	linux-doc, linux-kernel, Jonathan Corbet, Shuah Khan,
	Isaku Yamahata, Rick Edgecombe, Alexandru Elisei, Marc Zyngier,
	Oliver Upton, kvmarm, Wei-Lin Chang, Will Deacon, stable

On Tue, Nov 17, 2026, Fuad Tabba wrote:
> > But the overflow bug only applies to x86 (see below), so is this something
> > we should worry about at all?
> 
> The ring overflows on arm64 too (below). As for exit_reason, I asked
> Sean about the arm64 MMIO case on v1, and his answer was that a VMM
> that pre-faults between a KVM_EXIT_MMIO return and the next KVM_RUN
> "gets to deal with the fallout" [1]. I think the same goes for riscv's
> exits.
> 
> [...]
> > > diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst
> [...]
> > >  The dirty ring can get full.  When it happens, the KVM_RUN of the
> > > -vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL.
> > > +vcpu will return with exit reason KVM_EXIT_DIRTY_RING_FULL, and
> > > +KVM_PRE_FAULT_MEMORY on the vcpu will process no more pages until the
> > > +ring has been harvested and reset.
> >
> > Maybe worth mentioning the exit_reason thing if we keep this arch-generic?
> 
> Sure, I'll document that userspace should complete a pending exit with
> KVM_RUN before it pre-faults on that vCPU.

If we're going to do a documentation update, I vote to keep it vague and scary,
otherwise readers might think the exception proves the rule.  I.e. if we say
that KVM_PRE_FAULT_MEMORY isn't supported, then userspace might think all other
ioctls are safe, which is most definitely not the case.  E.g. something like

diff --git a/Documentation/virt/kvm/api.rst b/Documentation/virt/kvm/api.rst
index e95c9cda085d..45dc1e3c0b03 100644
--- a/Documentation/virt/kvm/api.rst
+++ b/Documentation/virt/kvm/api.rst
@@ -6971,10 +6971,13 @@ to the byte array.

       The pending state of the operation is not preserved in state which is
       visible to userspace, thus userspace should ensure that the operation is
-      completed before performing a live migration.  Userspace can re-enter the
-      guest with an unmasked signal pending or with the immediate_exit field set
-      to complete pending operations without allowing any further instructions
-      to be executed.
+      completed before performing a live migration.  In general, userspace should
+      exercise extreme caution when invoking ioctls other than KVM_RUN prior to
+      completing the original operation.
+
+      Userspace can re-enter the guest with an unmasked signal pending or with
+      the immediate_exit field set to complete pending operations without
+      allowing any further instructions to be executed.

 ::

^ permalink raw reply related	[flat|nested] 4+ messages in thread

end of thread, other threads:[~2026-11-19  0:25 UTC | newest]

Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
     [not found] <20261117074428.7544-1-fuad.tabba@linux.dev>
2026-11-17  7:44 ` [PATCH v2 1/2] KVM: Stop KVM_PRE_FAULT_MEMORY when the vCPU's dirty ring is full Fuad Tabba
2026-11-17 14:23   ` Lorenzo Stoakes (ARM)
2026-11-17 17:05     ` Fuad Tabba
2026-11-19  0:25       ` Sean Christopherson

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox