* [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; 5+ 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] 5+ 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; 5+ 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] 5+ 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; 5+ 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] 5+ 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 2026-11-19 7:54 ` Fuad Tabba 0 siblings, 1 reply; 5+ 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] 5+ messages in thread
* Re: [PATCH v2 1/2] KVM: Stop KVM_PRE_FAULT_MEMORY when the vCPU's dirty ring is full 2026-11-19 0:25 ` Sean Christopherson @ 2026-11-19 7:54 ` Fuad Tabba 0 siblings, 0 replies; 5+ messages in thread From: Fuad Tabba @ 2026-11-19 7:54 UTC (permalink / raw) To: Sean Christopherson 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 Hi Sean, On Thu, 19 Nov 2026 at 00:25, Sean Christopherson <seanjc@google.com> wrote: [...] > > > 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 I'll go with that in v3. Thanks, /fuad ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-19 7:54 UTC | newest]
Thread overview: 5+ 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
2026-11-19 7:54 ` Fuad Tabba
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox