Skip to contentSkip to conversation

KVM: arm64: Enable ring-based dirty memory tracking

PATCH Superseded Gavin Shan 5 participants 33 messages Nov 4, 2022 – Nov 8, 2022

Subsystems (7)
Documentation x86 KVM Kselftest +3 more subsystems

v8 of 10 Superseded Latest is v10 →

lore
Share & tools
lore

Gavin Shan

author
#0 lore raw

v8 cover KVM: arm64: Enable ring-based dirty memory tracking

This series enables the ring-based dirty memory tracking for ARM64. The feature has been available and enabled on x86 for a while. It is beneficial when the number of dirty pages is small in a checkpointing system or live migration scenario. More details can be found from fb04a1eddb1a ("KVM: X86: Implement ring-based dirty memory tracking").

This series is applied to v6.1.rc3, plus commit c227590467cb ("KVM:
Check KVM_CAP_DIRTY_LOG_{RING, RING_ACQ_REL} prior to enabling them"). The commit is currently in Marc's 'fixes' branch, targeting v6.1.rc4/5.

v7: https://lore.kernel.org/kvmarm/[email protected]/
v6: https://lore.kernel.org/kvmarm/[email protected]/
v5: https://lore.kernel.org/all/[email protected]/
v4: https://lore.kernel.org/kvmarm/[email protected]/
v3: https://lore.kernel.org/r/[email protected]
v2: https://lore.kernel.org/lkml/YyiV%[email protected]/T/
v1: https://lore.kernel.org/lkml/[email protected]

Testing
=======
(1) kvm/selftests/dirty_log_test
(2) Live migration by QEMU

Changelog
=========
v8:
* Pick review-by and ack-by (Peter/Sean)
* Drop chunk of code to clear KVM_REQ_DIRTY_RING_SOFT_FULL in kvm_dirty_ring_reset(). Add comments to say the event will be cleared by the VCPU thread next time when it enters the guest. All other changes related to kvm_dirty_ring_reset()
are dropped in PATCH[v8 1/7]. (Sean/Peter/Marc)
* Drop PATCH[v7 3/7] since it has been merged (Marc/Oliver)
* Document the order of DIRTY_RING_{ACQ_REL, WITH_BITMAP}, add check to ensure no memslots are created when DIRTY_RING_WITH_BITMAP is enabled, and add weak function kvm_arch_allow_write_without_running_vcpu() in PATCH[v8 3/7] (Oliver)
* Only keep ourself out of non-running-vcpu radar when vgic/its
tables are being saved in PATCH[v8 4/7] (Marc/Sean)
v7:
* Cut down #ifdef, avoid using 'container_of()', move the dirty-ring check after KVM_REQ_VM_DEAD, add comments
for kvm_dirty_ring_check_request(), use tab character
for KVM event definitions in kvm_host.h in PATCH[v7 01] (Sean)
* Add PATCH[v7 03] to recheck if the capability has
been advertised prior to enable RING/RING_ACEL_REL (Sean)
* Improve the description about capability RING_WITH_BITMAP, rename kvm_dirty_ring_exclusive() to kvm_use_dirty_bitmap()
in PATCH[v7 04/09] (Peter/Oliver/Sean)
* Add PATCH[v7 05/09] to improve no-running-vcpu report (Marc/Sean)
* Improve commit messages (Sean/Oliver)
v6:
* Add CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP, for arm64
to advertise KVM_CAP_DIRTY_RING_WITH_BITMAP in
PATCH[v6 3/8] (Oliver/Peter)
* Add helper kvm_dirty_ring_exclusive() to check if traditional bitmap-based dirty log tracking is
exclusive to dirty-ring in PATCH[v6 3/8] (Peter)
* Enable KVM_CAP_DIRTY_RING_WITH_BITMAP in PATCH[v6 5/8] (Gavin)
v5:
* Drop empty stub kvm_dirty_ring_check_request() (Marc/Peter)
* Add PATCH[v5 3/7] to allow using bitmap, indicated by
KVM_CAP_DIRTY_LOG_RING_ALLOW_BITMAP (Marc/Peter)
v4:

  * Commit log improvement                                     (Marc)
  * Add helper kvm_dirty_ring_check_request()                  (Marc)
  * Drop ifdef for kvm_cpu_dirty_log_size()                    (Marc)

v3:
* Check KVM_REQ_RING_SOFT_RULL inside kvm_request_pending() (Peter)
* Move declaration of kvm_cpu_dirty_log_size() (test-robot)
v2:

  * Introduce KVM_REQ_RING_SOFT_FULL                           (Marc)
  * Changelog improvement                                      (Marc)
  * Fix dirty_log_test without knowing host page size          (Drew)

Gavin Shan (7):
KVM: x86: Introduce KVM_REQ_DIRTY_RING_SOFT_FULL
KVM: Move declaration of kvm_cpu_dirty_log_size() to kvm_dirty_ring.h
KVM: Support dirty ring in conjunction with bitmap
KVM: arm64: Enable ring-based dirty memory tracking
KVM: selftests: Use host page size to map ring buffer in
dirty_log_test
KVM: selftests: Clear dirty ring states between two modes in
dirty_log_test
KVM: selftests: Automate choosing dirty ring size in dirty_log_test

 Documentation/virt/kvm/api.rst               | 35 ++++++++++---
 arch/arm64/include/uapi/asm/kvm.h            |  1 +
 arch/arm64/kvm/Kconfig                       |  2 +
 arch/arm64/kvm/arm.c                         |  3 ++
 arch/arm64/kvm/mmu.c                         | 15 ++++++
 arch/arm64/kvm/vgic/vgic-its.c               |  3 ++
 arch/arm64/kvm/vgic/vgic-mmio-v3.c           |  7 +++
 arch/x86/include/asm/kvm_host.h              |  2 -
 arch/x86/kvm/x86.c                           | 15 +++---
 include/kvm/arm_vgic.h                       |  2 +
 include/linux/kvm_dirty_ring.h               | 20 +++++---
 include/linux/kvm_host.h                     | 10 ++--
 include/uapi/linux/kvm.h                     |  1 +
 tools/testing/selftests/kvm/dirty_log_test.c | 53 ++++++++++++++------
 tools/testing/selftests/kvm/lib/kvm_util.c   |  2 +-
 virt/kvm/Kconfig                             |  8 +++
 virt/kvm/dirty_ring.c                        | 42 +++++++++++++++-
 virt/kvm/kvm_main.c                          | 52 +++++++++++++++----
 18 files changed, 214 insertions(+), 59 deletions(-)
Signature · 1 line
2.23.0
author
#1 lore raw

PATCH v8 1/7 KVM: x86: Introduce KVM_REQ_DIRTY_RING_SOFT_FULL

The VCPU isn't expected to be runnable when the dirty ring becomes soft full, until the dirty pages are harvested and the dirty ring is reset from userspace. So there is a check in each guest's entrace to see if the dirty ring is soft full or not. The VCPU is stopped from running if its dirty ring has been soft full. The similar check will be needed when the feature is going to be supported on ARM64. As Marc Zyngier suggested, a new event will avoid pointless overhead to check the size of the dirty ring ('vcpu->kvm->dirty_ring_size') in each guest's entrance.

Add KVM_REQ_DIRTY_RING_SOFT_FULL. The event is raised when the dirty ring becomes soft full in kvm_dirty_ring_push(). The event is only cleared in the check, done in the newly added helper kvm_dirty_ring_check_request(). Since the VCPU is not runnable when the dirty ring becomes soft full, the KVM_REQ_DIRTY_RING_SOFT_FULL event is always set to prevent the VCPU from running until the dirty pages are harvested and the dirty ring is reset by userspace.

kvm_dirty_ring_soft_full() becomes a private function with the newly added helper kvm_dirty_ring_check_request(). The alignment for the various event definitions in kvm_host.h is changed to tab character by the way. In order to avoid using 'container_of()', the argument @ring is replaced by @vcpu in kvm_dirty_ring_push().

---
 arch/x86/kvm/x86.c             | 15 ++++++---------
 include/linux/kvm_dirty_ring.h | 12 ++++--------
 include/linux/kvm_host.h       |  9 +++++----
 virt/kvm/dirty_ring.c          | 32 ++++++++++++++++++++++++++++++--
 virt/kvm/kvm_main.c            |  3 +--
 5 files changed, 46 insertions(+), 25 deletions(-)
arch/x86/kvm/x86.c +6 -9
index 521b433f978c..fd3347e31f5b 100644
@@ -10512,20 +10512,17 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
 
 	bool req_immediate_exit = false;
 
-	/* Forbid vmenter if vcpu dirty ring is soft-full */
-	if (unlikely(vcpu->kvm->dirty_ring_size &&
-		     kvm_dirty_ring_soft_full(&vcpu->dirty_ring))) {
-		vcpu->run->exit_reason = KVM_EXIT_DIRTY_RING_FULL;
-		trace_kvm_dirty_ring_exit(vcpu);
-		r = 0;
-		goto out;
-	}
-
 	if (kvm_request_pending(vcpu)) {
 		if (kvm_check_request(KVM_REQ_VM_DEAD, vcpu)) {
 			r = -EIO;
 			goto out;
 		}
+
+		if (kvm_dirty_ring_check_request(vcpu)) {
+			r = 0;
+			goto out;
+		}
+
 		if (kvm_check_request(KVM_REQ_GET_NESTED_STATE_PAGES, vcpu)) {
 			if (unlikely(!kvm_x86_ops.nested_ops->get_nested_state_pages(vcpu))) {
 				r = 0;
include/linux/kvm_dirty_ring.h +4 -8
index 906f899813dc..9c13c4c3d30c 100644
@@ -49,7 +49,7 @@ static inline int kvm_dirty_ring_reset(struct kvm *kvm,
 	return 0;
 }
 
-static inline void kvm_dirty_ring_push(struct kvm_dirty_ring *ring,
+static inline void kvm_dirty_ring_push(struct kvm_vcpu *vcpu,
 				       u32 slot, u64 offset)
 {
 }
@@ -64,11 +64,6 @@ static inline void kvm_dirty_ring_free(struct kvm_dirty_ring *ring)
 {
 }
 
-static inline bool kvm_dirty_ring_soft_full(struct kvm_dirty_ring *ring)
-{
-	return true;
-}
-
 #else /* CONFIG_HAVE_KVM_DIRTY_RING */
 
 u32 kvm_dirty_ring_get_rsvd_entries(void);
@@ -84,13 +79,14 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring);
  * returns =0: successfully pushed
  *         <0: unable to push, need to wait
  */
-void kvm_dirty_ring_push(struct kvm_dirty_ring *ring, u32 slot, u64 offset);
+void kvm_dirty_ring_push(struct kvm_vcpu *vcpu, u32 slot, u64 offset);
+
+bool kvm_dirty_ring_check_request(struct kvm_vcpu *vcpu);
 
 /* for use in vm_operations_struct */
 struct page *kvm_dirty_ring_get_page(struct kvm_dirty_ring *ring, u32 offset);
 
 void kvm_dirty_ring_free(struct kvm_dirty_ring *ring);
-bool kvm_dirty_ring_soft_full(struct kvm_dirty_ring *ring);
 
 #endif /* CONFIG_HAVE_KVM_DIRTY_RING */
 
include/linux/kvm_host.h +5 -4
index 18592bdf4c1b..6fab55e58111 100644
@@ -153,10 +153,11 @@ static inline bool is_error_page(struct page *page)
  * Architecture-independent vcpu->requests bit members
  * Bits 3-7 are reserved for more arch-independent bits.
  */
-#define KVM_REQ_TLB_FLUSH         (0 | KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
-#define KVM_REQ_VM_DEAD           (1 | KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
-#define KVM_REQ_UNBLOCK           2
-#define KVM_REQUEST_ARCH_BASE     8
+#define KVM_REQ_TLB_FLUSH		(0 | KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
+#define KVM_REQ_VM_DEAD			(1 | KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
+#define KVM_REQ_UNBLOCK			2
+#define KVM_REQ_DIRTY_RING_SOFT_FULL	3
+#define KVM_REQUEST_ARCH_BASE		8
 
 /*
  * KVM_REQ_OUTSIDE_GUEST_MODE exists is purely as way to force the vCPU to
virt/kvm/dirty_ring.c +30 -2
index d6fabf238032..fecbb7d75ad2 100644
@@ -26,7 +26,7 @@ static u32 kvm_dirty_ring_used(struct kvm_dirty_ring *ring)
 	return READ_ONCE(ring->dirty_index) - READ_ONCE(ring->reset_index);
 }
 
-bool kvm_dirty_ring_soft_full(struct kvm_dirty_ring *ring)
+static bool kvm_dirty_ring_soft_full(struct kvm_dirty_ring *ring)
 {
 	return kvm_dirty_ring_used(ring) >= ring->soft_limit;
 }
@@ -142,13 +142,19 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring)
 
 	kvm_reset_dirty_gfn(kvm, cur_slot, cur_offset, mask);
 
+	/*
+	 * The request KVM_REQ_DIRTY_RING_SOFT_FULL will be cleared
+	 * by the VCPU thread next time when it enters the guest.
+	 */
+
 	trace_kvm_dirty_ring_reset(ring);
 
 	return count;
 }
 
-void kvm_dirty_ring_push(struct kvm_dirty_ring *ring, u32 slot, u64 offset)
+void kvm_dirty_ring_push(struct kvm_vcpu *vcpu, u32 slot, u64 offset)
 {
+	struct kvm_dirty_ring *ring = &vcpu->dirty_ring;
 	struct kvm_dirty_gfn *entry;
 
 	/* It should never get full */
@@ -166,6 +172,28 @@ void kvm_dirty_ring_push(struct kvm_dirty_ring *ring, u32 slot, u64 offset)
 	kvm_dirty_gfn_set_dirtied(entry);
 	ring->dirty_index++;
 	trace_kvm_dirty_ring_push(ring, slot, offset);
+
+	if (kvm_dirty_ring_soft_full(ring))
+		kvm_make_request(KVM_REQ_DIRTY_RING_SOFT_FULL, vcpu);
+}
+
+bool kvm_dirty_ring_check_request(struct kvm_vcpu *vcpu)
+{
+	/*
+	 * The VCPU isn't runnable when the dirty ring becomes soft full.
+	 * The KVM_REQ_DIRTY_RING_SOFT_FULL event is always set to prevent
+	 * the VCPU from running until the dirty pages are harvested and
+	 * the dirty ring is reset by userspace.
+	 */
+	if (kvm_check_request(KVM_REQ_DIRTY_RING_SOFT_FULL, vcpu) &&
+	    kvm_dirty_ring_soft_full(&vcpu->dirty_ring)) {
+		kvm_make_request(KVM_REQ_DIRTY_RING_SOFT_FULL, vcpu);
+		vcpu->run->exit_reason = KVM_EXIT_DIRTY_RING_FULL;
+		trace_kvm_dirty_ring_exit(vcpu);
+		return true;
+	}
+
+	return false;
 }
 
 struct page *kvm_dirty_ring_get_page(struct kvm_dirty_ring *ring, u32 offset)
virt/kvm/kvm_main.c +1 -2
index 25d7872b29c1..c865d7d82685 100644
@@ -3314,8 +3314,7 @@ void mark_page_dirty_in_slot(struct kvm *kvm,
 		u32 slot = (memslot->as_id << 16) | memslot->id;
 
 		if (kvm->dirty_ring_size)
-			kvm_dirty_ring_push(&vcpu->dirty_ring,
-					    slot, rel_gfn);
+			kvm_dirty_ring_push(vcpu, slot, rel_gfn);
 		else
 			set_bit_le(rel_gfn, memslot->dirty_bitmap);
 	}
Signature · 1 line
2.23.0
author
#2 lore raw

PATCH v8 2/7 KVM: Move declaration of kvm_cpu_dirty_log_size() to kvm_dirty_ring.h

In reply to Gavin Shan

Not all architectures like ARM64 need to override the function. Move its declaration to kvm_dirty_ring.h to avoid the following compiling warning on ARM64 when the feature is enabled.

  arch/arm64/kvm/../../../virt/kvm/dirty_ring.c:14:12:        \
  warning: no previous prototype for 'kvm_cpu_dirty_log_size' \
  [-Wmissing-prototypes]                                      \
  int __weak kvm_cpu_dirty_log_size(void)
---
 arch/x86/include/asm/kvm_host.h | 2 --
 include/linux/kvm_dirty_ring.h  | 1 +
 2 files changed, 1 insertion(+), 2 deletions(-)
arch/x86/include/asm/kvm_host.h +0 -2
index 7551b6f9c31c..b4dbde7d9eb1 100644
@@ -2090,8 +2090,6 @@ static inline int kvm_cpu_get_apicid(int mps_cpu)
 #define GET_SMSTATE(type, buf, offset)		\
 	(*(type *)((buf) + (offset) - 0x7e00))
 
-int kvm_cpu_dirty_log_size(void);
-
 int memslot_rmap_alloc(struct kvm_memory_slot *slot, unsigned long npages);
 
 #define KVM_CLOCK_VALID_FLAGS						\
include/linux/kvm_dirty_ring.h +1 -0
index 9c13c4c3d30c..199ead37b104 100644
@@ -66,6 +66,7 @@ static inline void kvm_dirty_ring_free(struct kvm_dirty_ring *ring)
 
 #else /* CONFIG_HAVE_KVM_DIRTY_RING */
 
+int kvm_cpu_dirty_log_size(void);
 u32 kvm_dirty_ring_get_rsvd_entries(void);
 int kvm_dirty_ring_alloc(struct kvm_dirty_ring *ring, int index, u32 size);
 
Signature · 1 line
2.23.0
author
#3 lore raw

PATCH v8 3/7 KVM: Support dirty ring in conjunction with bitmap

In reply to Gavin Shan

ARM64 needs to dirty memory outside of a VCPU context when VGIC/ITS is enabled. It's conflicting with that ring-based dirty page tracking always requires a running VCPU context.

Introduce a new flavor of dirty ring that requires the use of both VCPU dirty rings and a dirty bitmap. The expectation is that for non-VCPU sources of dirty memory (such as the VGIC/ITS on arm64), KVM writes to the dirty bitmap. Userspace should scan the dirty bitmap before migrating the VM to the target.

Use an additional capability to advertise this behavior. The newly added capability (KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP) can't be enabled before KVM_CAP_DIRTY_LOG_RING_ACQ_REL on ARM64. In this way, the newly added capability is treated as an extension of KVM_CAP_DIRTY_LOG_RING_ACQ_REL.

---
 Documentation/virt/kvm/api.rst | 33 ++++++++++++++++++-----
 include/linux/kvm_dirty_ring.h |  7 +++++
 include/linux/kvm_host.h       |  1 +
 include/uapi/linux/kvm.h       |  1 +
 virt/kvm/Kconfig               |  8 ++++++
 virt/kvm/dirty_ring.c          | 10 +++++++
 virt/kvm/kvm_main.c            | 49 +++++++++++++++++++++++++++-------
 7 files changed, 93 insertions(+), 16 deletions(-)
Documentation/virt/kvm/api.rst +26 -7
index eee9f857a986..2ec32bd41792 100644
@@ -8003,13 +8003,6 @@ flushing is done by the KVM_GET_DIRTY_LOG ioctl).  To achieve that, one
 needs to kick the vcpu out of KVM_RUN using a signal.  The resulting
 vmexit ensures that all dirty GFNs are flushed to the dirty rings.
 
-NOTE: the capability KVM_CAP_DIRTY_LOG_RING and the corresponding
-ioctl KVM_RESET_DIRTY_RINGS are mutual exclusive to the existing ioctls
-KVM_GET_DIRTY_LOG and KVM_CLEAR_DIRTY_LOG.  After enabling
-KVM_CAP_DIRTY_LOG_RING with an acceptable dirty ring size, the virtual
-machine will switch to ring-buffer dirty page tracking and further
-KVM_GET_DIRTY_LOG or KVM_CLEAR_DIRTY_LOG ioctls will fail.
-
 NOTE: KVM_CAP_DIRTY_LOG_RING_ACQ_REL is the only capability that
 should be exposed by weakly ordered architecture, in order to indicate
 the additional memory ordering requirements imposed on userspace when
@@ -8018,6 +8011,32 @@ Architecture with TSO-like ordering (such as x86) are allowed to
 expose both KVM_CAP_DIRTY_LOG_RING and KVM_CAP_DIRTY_LOG_RING_ACQ_REL
 to userspace.
 
+After using the dirty rings, the userspace needs to detect the capability
+of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures
+need to be backed by per-slot bitmaps. With this capability advertised
+and supported, it means the architecture can dirty guest pages without
+vcpu/ring context, so that some of the dirty information will still be
+maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP
+can't be enabled until the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL
+has been enabled.
+
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.
+
+NOTE: One example of using the backup bitmap is saving arm64 vgic/its
+tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on
+KVM device "kvm-arm-vgic-its" during VM's migration.
+
 8.30 KVM_CAP_XEN_HVM
 --------------------
 
include/linux/kvm_dirty_ring.h +7 -0
index 199ead37b104..4862c98d80d3 100644
@@ -37,6 +37,11 @@ static inline u32 kvm_dirty_ring_get_rsvd_entries(void)
 	return 0;
 }
 
+static inline bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
+	return true;
+}
+
 static inline int kvm_dirty_ring_alloc(struct kvm_dirty_ring *ring,
 				       int index, u32 size)
 {
@@ -67,6 +72,8 @@ static inline void kvm_dirty_ring_free(struct kvm_dirty_ring *ring)
 #else /* CONFIG_HAVE_KVM_DIRTY_RING */
 
 int kvm_cpu_dirty_log_size(void);
+bool kvm_use_dirty_bitmap(struct kvm *kvm);
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm);
 u32 kvm_dirty_ring_get_rsvd_entries(void);
 int kvm_dirty_ring_alloc(struct kvm_dirty_ring *ring, int index, u32 size);
 
include/linux/kvm_host.h +1 -0
index 6fab55e58111..f51eb9419bfc 100644
@@ -779,6 +779,7 @@ struct kvm {
 	pid_t userspace_pid;
 	unsigned int max_halt_poll_ns;
 	u32 dirty_ring_size;
+	bool dirty_ring_with_bitmap;
 	bool vm_bugged;
 	bool vm_dead;
 
include/uapi/linux/kvm.h +1 -0
index 0d5d4419139a..c87b5882d7ae 100644
@@ -1178,6 +1178,7 @@ struct kvm_ppc_resize_hpt {
 #define KVM_CAP_S390_ZPCI_OP 221
 #define KVM_CAP_S390_CPU_TOPOLOGY 222
 #define KVM_CAP_DIRTY_LOG_RING_ACQ_REL 223
+#define KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP 224
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
virt/kvm/Kconfig +8 -0
index 800f9470e36b..228be1145cf3 100644
@@ -33,6 +33,14 @@ config HAVE_KVM_DIRTY_RING_ACQ_REL
        bool
        select HAVE_KVM_DIRTY_RING
 
+# Only architectures that need to dirty memory outside of a vCPU
+# context should select this, advertising to userspace the
+# requirement to use a dirty bitmap in addition to the vCPU dirty
+# ring.
+config HAVE_KVM_DIRTY_RING_WITH_BITMAP
+	bool
+	depends on HAVE_KVM_DIRTY_RING
+
 config HAVE_KVM_EVENTFD
        bool
        select EVENTFD
virt/kvm/dirty_ring.c +10 -0
index fecbb7d75ad2..758679724447 100644
@@ -21,6 +21,16 @@ u32 kvm_dirty_ring_get_rsvd_entries(void)
 	return KVM_DIRTY_RING_RSVD_ENTRIES + kvm_cpu_dirty_log_size();
 }
 
+bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
+	return !kvm->dirty_ring_size || kvm->dirty_ring_with_bitmap;
+}
+
+bool __weak kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return false;
+}
+
 static u32 kvm_dirty_ring_used(struct kvm_dirty_ring *ring)
 {
 	return READ_ONCE(ring->dirty_index) - READ_ONCE(ring->reset_index);
virt/kvm/kvm_main.c +40 -9

97 lines not on this page · raw message

Signature · 1 line
2.23.0
maintainer
#4 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 51 lines · Gavin Shan

ARM64 needs to dirty memory outside of a VCPU context when VGIC/ITS is enabled. It's conflicting with that ring-based dirty page tracking always requires a running VCPU context.

Introduce a new flavor of dirty ring that requires the use of both VCPU dirty rings and a dirty bitmap. The expectation is that for non-VCPU sources of dirty memory (such as the VGIC/ITS on arm64), KVM writes to the dirty bitmap. Userspace should scan the dirty bitmap before migrating the VM to the target.

Use an additional capability to advertise this behavior. The newly added capability (KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP) can't be enabled before KVM_CAP_DIRTY_LOG_RING_ACQ_REL on ARM64. In this way, the newly added capability is treated as an extension of KVM_CAP_DIRTY_LOG_RING_ACQ_REL.

---
 Documentation/virt/kvm/api.rst | 33 ++++++++++++++++++-----
 include/linux/kvm_dirty_ring.h |  7 +++++
 include/linux/kvm_host.h       |  1 +
 include/uapi/linux/kvm.h       |  1 +
 virt/kvm/Kconfig               |  8 ++++++
 virt/kvm/dirty_ring.c          | 10 +++++++
 virt/kvm/kvm_main.c            | 49 +++++++++++++++++++++++++++-------
 7 files changed, 93 insertions(+), 16 deletions(-)
Documentation/virt/kvm/api.rst +0 -7
index eee9f857a986..2ec32bd41792 100644
@@ -8003,13 +8003,6 @@ flushing is done by the KVM_GET_DIRTY_LOG ioctl).  To achieve that, one
 needs to kick the vcpu out of KVM_RUN using a signal.  The resulting
 vmexit ensures that all dirty GFNs are flushed to the dirty rings.
 
-NOTE: the capability KVM_CAP_DIRTY_LOG_RING and the corresponding
-ioctl KVM_RESET_DIRTY_RINGS are mutual exclusive to the existing ioctls
-KVM_GET_DIRTY_LOG and KVM_CLEAR_DIRTY_LOG.  After enabling
-KVM_CAP_DIRTY_LOG_RING with an acceptable dirty ring size, the virtual
-machine will switch to ring-buffer dirty page tracking and further
-KVM_GET_DIRTY_LOG or KVM_CLEAR_DIRTY_LOG ioctls will fail.
-
 NOTE: KVM_CAP_DIRTY_LOG_RING_ACQ_REL is the only capability that
 should be exposed by weakly ordered architecture, in order to indicate
 the additional memory ordering requirements imposed on userspace when

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8014

Quoted 4 lines
Documentation/virt/kvm/api.rst +1 -0
@@ -8018,6 +8011,32 @@ Architecture with TSO-like ordering (such as x86) are allowed to
 expose both KVM_CAP_DIRTY_LOG_RING and KVM_CAP_DIRTY_LOG_RING_ACQ_REL
 to userspace.
 
+After using the dirty rings, the userspace needs to detect the capability

using? or enabling? What comes after suggest the latter.

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8017

Quoted 3 lines
Documentation/virt/kvm/api.rst +3 -0
+of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures
+need to be backed by per-slot bitmaps. With this capability advertised
+and supported, it means the architecture can dirty guest pages without

If it is advertised, it is supported, right?

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8024

Quoted 7 lines
Documentation/virt/kvm/api.rst +7 -0
+vcpu/ring context, so that some of the dirty information will still be
+maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP
+can't be enabled until the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL
+has been enabled.
+
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8034

Quoted 10 lines
Documentation/virt/kvm/api.rst +10 -0
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.

It isn't clear to me why KVM_CLEAR_DIRTY_LOG should be called out. If you have multiple devices that dirty the memory, such as multiple ITSs, why shouldn't userspace be allowed to snapshot the dirty state multiple time? This doesn't seem like a reasonable restriction, and I really dislike the idea of undefined behaviour here.

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8038

Quoted 4 lines
Documentation/virt/kvm/api.rst +4 -0
+
+NOTE: One example of using the backup bitmap is saving arm64 vgic/its
+tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on
+KVM device "kvm-arm-vgic-its" during VM's migration.

It would be good to have something about this in the ITS documentation. Something along these lines:

Documentation/virt/kvm/devices/arm-vgic-its.rst +4 -1
index d257eddbae29..e053124f77c4 100644
@@ -52,7 +52,10 @@ KVM_DEV_ARM_VGIC_GRP_CTRL
 
     KVM_DEV_ARM_ITS_SAVE_TABLES
       save the ITS table data into guest RAM, at the location provisioned
-      by the guest in corresponding registers/table entries.
+      by the guest in corresponding registers/table entries. Should userspace
+      require a form of dirty tracking to identify which pages are modified
+      by the saving process, it should use a bitmap even if using another
+      mechanism to track the memory dirtied by the vCPUs.
 
       The layout of the tables in guest memory defines an ABI. The entries
       are laid out in little endian format as described in the last paragraph.
Quoted 180 lines
Documentation/virt/kvm/api.rst +1 -0
+
 8.30 KVM_CAP_XEN_HVM
 --------------------
 
include/linux/kvm_dirty_ring.h +7 -0
index 199ead37b104..4862c98d80d3 100644
@@ -37,6 +37,11 @@ static inline u32 kvm_dirty_ring_get_rsvd_entries(void)
 	return 0;
 }
 
+static inline bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
+	return true;
+}
+
 static inline int kvm_dirty_ring_alloc(struct kvm_dirty_ring *ring,
 				       int index, u32 size)
 {
@@ -67,6 +72,8 @@ static inline void kvm_dirty_ring_free(struct kvm_dirty_ring *ring)
 #else /* CONFIG_HAVE_KVM_DIRTY_RING */
 
 int kvm_cpu_dirty_log_size(void);
+bool kvm_use_dirty_bitmap(struct kvm *kvm);
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm);
 u32 kvm_dirty_ring_get_rsvd_entries(void);
 int kvm_dirty_ring_alloc(struct kvm_dirty_ring *ring, int index, u32 size);
 
include/linux/kvm_host.h +1 -0
index 6fab55e58111..f51eb9419bfc 100644
@@ -779,6 +779,7 @@ struct kvm {
 	pid_t userspace_pid;
 	unsigned int max_halt_poll_ns;
 	u32 dirty_ring_size;
+	bool dirty_ring_with_bitmap;
 	bool vm_bugged;
 	bool vm_dead;
 
include/uapi/linux/kvm.h +1 -0
index 0d5d4419139a..c87b5882d7ae 100644
@@ -1178,6 +1178,7 @@ struct kvm_ppc_resize_hpt {
 #define KVM_CAP_S390_ZPCI_OP 221
 #define KVM_CAP_S390_CPU_TOPOLOGY 222
 #define KVM_CAP_DIRTY_LOG_RING_ACQ_REL 223
+#define KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP 224
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
virt/kvm/Kconfig +8 -0
index 800f9470e36b..228be1145cf3 100644
@@ -33,6 +33,14 @@ config HAVE_KVM_DIRTY_RING_ACQ_REL
        bool
        select HAVE_KVM_DIRTY_RING
 
+# Only architectures that need to dirty memory outside of a vCPU
+# context should select this, advertising to userspace the
+# requirement to use a dirty bitmap in addition to the vCPU dirty
+# ring.
+config HAVE_KVM_DIRTY_RING_WITH_BITMAP
+	bool
+	depends on HAVE_KVM_DIRTY_RING
+
 config HAVE_KVM_EVENTFD
        bool
        select EVENTFD
virt/kvm/dirty_ring.c +10 -0
index fecbb7d75ad2..758679724447 100644
@@ -21,6 +21,16 @@ u32 kvm_dirty_ring_get_rsvd_entries(void)
 	return KVM_DIRTY_RING_RSVD_ENTRIES + kvm_cpu_dirty_log_size();
 }
 
+bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
+	return !kvm->dirty_ring_size || kvm->dirty_ring_with_bitmap;
+}
+
+bool __weak kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return false;
+}
+
 static u32 kvm_dirty_ring_used(struct kvm_dirty_ring *ring)
 {
 	return READ_ONCE(ring->dirty_index) - READ_ONCE(ring->reset_index);
virt/kvm/kvm_main.c +21 -9
index c865d7d82685..746133b23a66 100644
@@ -1617,7 +1617,7 @@ static int kvm_prepare_memory_region(struct kvm *kvm,
 			new->dirty_bitmap = NULL;
 		else if (old && old->dirty_bitmap)
 			new->dirty_bitmap = old->dirty_bitmap;
-		else if (!kvm->dirty_ring_size) {
+		else if (kvm_use_dirty_bitmap(kvm)) {
 			r = kvm_alloc_dirty_bitmap(new);
 			if (r)
 				return r;
@@ -2060,8 +2060,8 @@ int kvm_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log,
 	unsigned long n;
 	unsigned long any = 0;
 
-	/* Dirty ring tracking is exclusive to dirty log tracking */
-	if (kvm->dirty_ring_size)
+	/* Dirty ring tracking may be exclusive to dirty log tracking */
+	if (!kvm_use_dirty_bitmap(kvm))
 		return -ENXIO;
 
 	*memslot = NULL;
@@ -2125,8 +2125,8 @@ static int kvm_get_dirty_log_protect(struct kvm *kvm, struct kvm_dirty_log *log)
 	unsigned long *dirty_bitmap_buffer;
 	bool flush;
 
-	/* Dirty ring tracking is exclusive to dirty log tracking */
-	if (kvm->dirty_ring_size)
+	/* Dirty ring tracking may be exclusive to dirty log tracking */
+	if (!kvm_use_dirty_bitmap(kvm))
 		return -ENXIO;
 
 	as_id = log->slot >> 16;
@@ -2237,8 +2237,8 @@ static int kvm_clear_dirty_log_protect(struct kvm *kvm,
 	unsigned long *dirty_bitmap_buffer;
 	bool flush;
 
-	/* Dirty ring tracking is exclusive to dirty log tracking */
-	if (kvm->dirty_ring_size)
+	/* Dirty ring tracking may be exclusive to dirty log tracking */
+	if (!kvm_use_dirty_bitmap(kvm))
 		return -ENXIO;
 
 	as_id = log->slot >> 16;
@@ -3305,7 +3305,10 @@ void mark_page_dirty_in_slot(struct kvm *kvm,
 	struct kvm_vcpu *vcpu = kvm_get_running_vcpu();
 
 #ifdef CONFIG_HAVE_KVM_DIRTY_RING
-	if (WARN_ON_ONCE(!vcpu) || WARN_ON_ONCE(vcpu->kvm != kvm))
+	if (WARN_ON_ONCE(vcpu && vcpu->kvm != kvm))
+		return;
+
+	if (WARN_ON_ONCE(!kvm_arch_allow_write_without_running_vcpu(kvm) && !vcpu))
 		return;
 #endif
 
@@ -3313,7 +3316,7 @@ void mark_page_dirty_in_slot(struct kvm *kvm,
 		unsigned long rel_gfn = gfn - memslot->base_gfn;
 		u32 slot = (memslot->as_id << 16) | memslot->id;
 
-		if (kvm->dirty_ring_size)
+		if (kvm->dirty_ring_size && vcpu)
 			kvm_dirty_ring_push(vcpu, slot, rel_gfn);
 		else
 			set_bit_le(rel_gfn, memslot->dirty_bitmap);
@@ -4482,6 +4485,9 @@ static long kvm_vm_ioctl_check_extension_generic(struct kvm *kvm, long arg)
 		return KVM_DIRTY_RING_MAX_ENTRIES * sizeof(struct kvm_dirty_gfn);
 #else
 		return 0;
+#endif
+#ifdef CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP
+	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP:
 #endif
 	case KVM_CAP_BINARY_STATS_FD:
 	case KVM_CAP_SYSTEM_EVENT_DATA:
@@ -4588,6 +4594,31 @@ static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
 			return -EINVAL;
 
 		return kvm_vm_ioctl_enable_dirty_log_ring(kvm, cap->args[0]);
+	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP: {
+		struct kvm_memslots *slots;
+		int r = -EINVAL;
+
+		if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
+		    !kvm->dirty_ring_size)

virt/kvm/kvm_main.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4612

Quoted 10 lines
virt/kvm/kvm_main.c +10 -0
+			return r;
+
+		mutex_lock(&kvm->slots_lock);
+
+		slots = kvm_memslots(kvm);
+
+		/*
+		 * Avoid a race between memslot creation and enabling the ring +
+		 * bitmap capability to guarantee that no memslots have been
+		 * created without a bitmap.

It should be called out in the documentation that this capability must be enabled before any memslot is created.

virt/kvm/kvm_main.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4624

Quoted 12 lines
virt/kvm/kvm_main.c +9 -0
+		 */
+		if (kvm_memslots_empty(slots)) {
+			kvm->dirty_ring_with_bitmap = cap->args[0];
+			r = 0;
+		}
+
+		mutex_unlock(&kvm->slots_lock);
+		return r;
+	}
 	default:
 		return kvm_vm_ioctl_enable_cap(kvm, cap);
 	}

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
#5 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Hi, Marc,

Quoted 6 lines · Marc Zyngier

Review

Quoted 2 lines
(quoted diff) +2 -0
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

The thing is the current with-bitmap design assumes that the two logs are collected in different windows of migration, while the dirty log is only collected after the VM is stopped. So collecting dirty bitmap and sending the dirty pages within the bitmap will be part of the VM downtime.

It will stop to make sense if the dirty bitmap can contain a large portion of the guest memory, because then it'll be simpler to just stop the VM, transfer pages, and restart on dest node without any tracking mechanism.

[1]

Quoted 17 lines

Review

Quoted 11 lines
(quoted diff) +10 -0
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.

It isn't clear to me why KVM_CLEAR_DIRTY_LOG should be called out. If you have multiple devices that dirty the memory, such as multiple ITSs, why shouldn't userspace be allowed to snapshot the dirty state multiple time? This doesn't seem like a reasonable restriction, and I really dislike the idea of undefined behaviour here.

I suggested the paragraph because it's very natural to ask whether we'd need to CLEAR_LOG for this special GET_LOG phase, so I thought this could be helpful as a reference to answer that.

I wanted to make it clear that we don't need CLEAR_LOG at all in this case, as fundamentally clear log is about re-protect the guest pages, but if we're with the restriction of above (having the dirty bmap the last to collect and once and for all) then it'll make no sense to protect the guest page at all at this stage since src host shouldn't run after the GET_LOG then the CLEAR_LOG will be a vain effort.

I used "undefined" here just to be loose on the interface, also a hint that we should never do that for this specific GET_LOG. If we want, we can ignore CLEAR_LOG in the future with ALLOW_BITMAP, and the undefined also provides the flexibility, but that's not really that important.

The wording could definitely be improved, or maybe even avoid mentioning the CLEAR_LOG might help, but IIUC the major thing to reach the consensus is not CLEAR_LOG itself but on whether we can have that assumption [1] and whether such a design of using dirty bmap is acceptable in general.

Thanks,

Signature · 1 line
Peter Xu
maintainer
#6 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Hi Peter,

Quoted 11 lines · Peter Xu

Hi, Marc,

Quoted 6 lines · Marc Zyngier

Review

Quoted 2 lines
(quoted diff) +2 -0
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Quoted 8 lines

The thing is the current with-bitmap design assumes that the two logs are collected in different windows of migration, while the dirty log is only collected after the VM is stopped. So collecting dirty bitmap and sending the dirty pages within the bitmap will be part of the VM downtime.

It will stop to make sense if the dirty bitmap can contain a large portion of the guest memory, because then it'll be simpler to just stop the VM, transfer pages, and restart on dest node without any tracking mechanism.

Oh, I absolutely agree that the whole vcpu dirty ring makes zero sense in general. It only makes sense if the source of the dirty pages is limited to the vcpus, which is literally a corner case. Look at any real machine, and you'll quickly realise that this isn't the case, and that DMA *is* a huge source of dirty pages.

Here, we're just lucky enough not to have much DMA tracking yet. Once that happens (and I have it from people doing the actual work that it *is* happening), you'll realise that the dirty ring story is of very limited use. So I'd rather drop anything quantitative here, as this is likely to be wrong.

Quoted 25 lines

[1]

Quoted 17 lines

Review

Quoted 11 lines
(quoted diff) +10 -0
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.

It isn't clear to me why KVM_CLEAR_DIRTY_LOG should be called out. If you have multiple devices that dirty the memory, such as multiple ITSs, why shouldn't userspace be allowed to snapshot the dirty state multiple time? This doesn't seem like a reasonable restriction, and I really dislike the idea of undefined behaviour here.

I suggested the paragraph because it's very natural to ask whether we'd need to CLEAR_LOG for this special GET_LOG phase, so I thought this could be helpful as a reference to answer that.

Quoted 6 lines

I wanted to make it clear that we don't need CLEAR_LOG at all in this case, as fundamentally clear log is about re-protect the guest pages, but if we're with the restriction of above (having the dirty bmap the last to collect and once and for all) then it'll make no sense to protect the guest page at all at this stage since src host shouldn't run after the GET_LOG then the CLEAR_LOG will be a vain effort.

That's not for you to decide, but userspace. I can perfectly expect userspace saving an ITS, getting the bitmap, saving the pages and then *clearing the log* before processing the next ITS. Or anything else.

And by the way, userspace is perfectly entitled to *restart* the VM on the spot if it wants to. After all, there is absolutely nothing that says "migration" here. You are reading it all over the place, but that's not what the API is about.

Frankly, I don't see why we should put random limitation to this API. We're not in the business of setting policies on what userspace does.

Quoted 10 lines

I used "undefined" here just to be loose on the interface, also a hint that we should never do that for this specific GET_LOG. If we want, we can ignore CLEAR_LOG in the future with ALLOW_BITMAP, and the undefined also provides the flexibility, but that's not really that important.

The wording could definitely be improved, or maybe even avoid mentioning the CLEAR_LOG might help, but IIUC the major thing to reach the consensus is not CLEAR_LOG itself but on whether we can have that assumption [1] and whether such a design of using dirty bmap is acceptable in general.

I don't know what [1] is, but the bitmap should behave correctly, no matter what userspace does, and provide consistent results. We already depend on this. If the current API cannot support this correctly, then we should fix it before I take this series.

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
#7 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 30 lines · Marc Zyngier

Hi Peter,

Quoted 11 lines · Peter Xu

Hi, Marc,

Quoted 6 lines · Marc Zyngier

Review

Quoted 2 lines
(quoted diff) +2 -0
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Quoted 8 lines

The thing is the current with-bitmap design assumes that the two logs are collected in different windows of migration, while the dirty log is only collected after the VM is stopped. So collecting dirty bitmap and sending the dirty pages within the bitmap will be part of the VM downtime.

It will stop to make sense if the dirty bitmap can contain a large portion of the guest memory, because then it'll be simpler to just stop the VM, transfer pages, and restart on dest node without any tracking mechanism.

Oh, I absolutely agree that the whole vcpu dirty ring makes zero sense in general. It only makes sense if the source of the dirty pages is limited to the vcpus, which is literally a corner case. Look at any real machine, and you'll quickly realise that this isn't the case, and that DMA *is* a huge source of dirty pages.

Quoted 5 lines

Here, we're just lucky enough not to have much DMA tracking yet. Once that happens (and I have it from people doing the actual work that it *is* happening), you'll realise that the dirty ring story is of very limited use. So I'd rather drop anything quantitative here, as this is likely to be wrong.

Is it a must that arm64 needs to track device DMAs using the same dirty tracking interface rather than VFIO or any other interface? It's definitely not the case for x86, but if it's true for arm64, then could the DMA be spread across all the guest pages? If it's also true, I really don't know how this will work..

We're only syncing the dirty bitmap once right now with the protocol. If that can cover most of the guest mem, it's same as non-live. If we sync it periodically, then it's the same as enabling dirty-log alone and the rings are useless.

Quoted 33 lines
Quoted 26 lines

[1]

Quoted 17 lines

Review

Quoted 11 lines
(quoted diff) +10 -0
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.

It isn't clear to me why KVM_CLEAR_DIRTY_LOG should be called out. If you have multiple devices that dirty the memory, such as multiple ITSs, why shouldn't userspace be allowed to snapshot the dirty state multiple time? This doesn't seem like a reasonable restriction, and I really dislike the idea of undefined behaviour here.

I suggested the paragraph because it's very natural to ask whether we'd need to CLEAR_LOG for this special GET_LOG phase, so I thought this could be helpful as a reference to answer that.

Quoted 6 lines

I wanted to make it clear that we don't need CLEAR_LOG at all in this case, as fundamentally clear log is about re-protect the guest pages, but if we're with the restriction of above (having the dirty bmap the last to collect and once and for all) then it'll make no sense to protect the guest page at all at this stage since src host shouldn't run after the GET_LOG then the CLEAR_LOG will be a vain effort.

Quoted 3 lines

That's not for you to decide, but userspace. I can perfectly expect userspace saving an ITS, getting the bitmap, saving the pages and then *clearing the log* before processing the next ITS. Or anything else.

I think I can get your point on why you're not happy with the document, but IMHO how we document is one thing, how it'll work is another. I preferred explicit documentation because it'll help the app developer to support the interface, also more docs to reference in the future; no strong opinion, though.

However if there's fundamental statement that was literally wrong, then it's another thing, and we may need to rethink.

Thanks,

Signature · 1 line
Peter Xu
author
#8 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Hi Peter and Marc,

Quoted 38 lines · Peter Xu
Quoted 25 lines · Marc Zyngier
Quoted 8 lines · Peter Xu
Quoted 6 lines · Marc Zyngier

Review

Quoted 2 lines
(quoted diff) +2 -0
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Quoted 8 lines

The thing is the current with-bitmap design assumes that the two logs are collected in different windows of migration, while the dirty log is only collected after the VM is stopped. So collecting dirty bitmap and sending the dirty pages within the bitmap will be part of the VM downtime.

It will stop to make sense if the dirty bitmap can contain a large portion of the guest memory, because then it'll be simpler to just stop the VM, transfer pages, and restart on dest node without any tracking mechanism.

Oh, I absolutely agree that the whole vcpu dirty ring makes zero sense in general. It only makes sense if the source of the dirty pages is limited to the vcpus, which is literally a corner case. Look at any real machine, and you'll quickly realise that this isn't the case, and that DMA *is* a huge source of dirty pages.

Quoted 5 lines

Here, we're just lucky enough not to have much DMA tracking yet. Once that happens (and I have it from people doing the actual work that it *is* happening), you'll realise that the dirty ring story is of very limited use. So I'd rather drop anything quantitative here, as this is likely to be wrong.

Is it a must that arm64 needs to track device DMAs using the same dirty tracking interface rather than VFIO or any other interface? It's definitely not the case for x86, but if it's true for arm64, then could the DMA be spread across all the guest pages? If it's also true, I really don't know how this will work..

Quoted 5 lines

We're only syncing the dirty bitmap once right now with the protocol. If that can cover most of the guest mem, it's same as non-live. If we sync it periodically, then it's the same as enabling dirty-log alone and the rings are useless.

For vgic/its tables, the number of dirty pages can be huge in theory. However, they're limited in practice. So I intend to agree with Peter that dirty-ring should be avoided and dirty-log needs to be used instead when the DMA case is supported in future. As Peter said, the small amount of dirty pages in the bitmap is the condition to use it here. I think it makes sense to mention it in the document.

Quoted 37 lines
Quoted 33 lines
Quoted 26 lines

[1]

Quoted 17 lines

Review

Quoted 11 lines
(quoted diff) +10 -0
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.

It isn't clear to me why KVM_CLEAR_DIRTY_LOG should be called out. If you have multiple devices that dirty the memory, such as multiple ITSs, why shouldn't userspace be allowed to snapshot the dirty state multiple time? This doesn't seem like a reasonable restriction, and I really dislike the idea of undefined behaviour here.

I suggested the paragraph because it's very natural to ask whether we'd need to CLEAR_LOG for this special GET_LOG phase, so I thought this could be helpful as a reference to answer that.

Quoted 6 lines

I wanted to make it clear that we don't need CLEAR_LOG at all in this case, as fundamentally clear log is about re-protect the guest pages, but if we're with the restriction of above (having the dirty bmap the last to collect and once and for all) then it'll make no sense to protect the guest page at all at this stage since src host shouldn't run after the GET_LOG then the CLEAR_LOG will be a vain effort.

Quoted 3 lines

That's not for you to decide, but userspace. I can perfectly expect userspace saving an ITS, getting the bitmap, saving the pages and then *clearing the log* before processing the next ITS. Or anything else.

Quoted 9 lines

I think I can get your point on why you're not happy with the document, but IMHO how we document is one thing, how it'll work is another. I preferred explicit documentation because it'll help the app developer to support the interface, also more docs to reference in the future; no strong opinion, though.

However if there's fundamental statement that was literally wrong, then it's another thing, and we may need to rethink.

How about to avoid mentioning KVM_CLEAR_DIRTY_LOG here? I don't expect QEMU to clear the dirty bitmap after it's collected in this particular case.

Thanks,
Gavin

maintainer
#9 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 48 lines · Gavin Shan

Hi Peter and Marc,

Quoted 38 lines · Peter Xu
Quoted 25 lines · Marc Zyngier
Quoted 8 lines · Peter Xu
Quoted 6 lines · Marc Zyngier

Review

Quoted 2 lines
(quoted diff) +2 -0
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Quoted 8 lines

The thing is the current with-bitmap design assumes that the two logs are collected in different windows of migration, while the dirty log is only collected after the VM is stopped. So collecting dirty bitmap and sending the dirty pages within the bitmap will be part of the VM downtime.

It will stop to make sense if the dirty bitmap can contain a large portion of the guest memory, because then it'll be simpler to just stop the VM, transfer pages, and restart on dest node without any tracking mechanism.

Oh, I absolutely agree that the whole vcpu dirty ring makes zero sense in general. It only makes sense if the source of the dirty pages is limited to the vcpus, which is literally a corner case. Look at any real machine, and you'll quickly realise that this isn't the case, and that DMA *is* a huge source of dirty pages.

Quoted 5 lines

Here, we're just lucky enough not to have much DMA tracking yet. Once that happens (and I have it from people doing the actual work that it *is* happening), you'll realise that the dirty ring story is of very limited use. So I'd rather drop anything quantitative here, as this is likely to be wrong.

Is it a must that arm64 needs to track device DMAs using the same dirty tracking interface rather than VFIO or any other interface? It's definitely not the case for x86, but if it's true for arm64, then could the DMA be spread across all the guest pages? If it's also true, I really don't know how this will work..

Quoted 5 lines

We're only syncing the dirty bitmap once right now with the protocol. If that can cover most of the guest mem, it's same as non-live. If we sync it periodically, then it's the same as enabling dirty-log alone and the rings are useless.

Quoted 6 lines

For vgic/its tables, the number of dirty pages can be huge in theory. However, they're limited in practice. So I intend to agree with Peter that dirty-ring should be avoided and dirty-log needs to be used instead when the DMA case is supported in future. As Peter said, the small amount of dirty pages in the bitmap is the condition to use it here. I think it makes sense to mention it in the document.

And again, I disagree. This API has *nothing* to do with the ITS. It is completely general purpose and should work with anything because it is designed for that.

The problem is that you're considering that RING+BITMAP is a different thing from BITMAP alone when it comes to non-CPU traffic. It really isn't. We can't say "there will only be a few pages dirtied", because we simply don't know.

If you really want a quantitative argument then say something like:

"The use of the ring+bitmap combination is only beneficial if there is only very little memory that is dirtied by non-CPU agents. Consider using the stand-alone bitmap API if this isn't the case."

which clearly puts the choice in the hand of the user.

[...]

Quoted 2 lines

How about to avoid mentioning KVM_CLEAR_DIRTY_LOG here? I don't expect QEMU to clear the dirty bitmap after it's collected in this particular case.

Peter said there is an undefined behaviour. I want to understand whether this is the case or not. QEMU is only one of the users of this stuff, as all the vendors have their own custom VMM, and they do things in funny ways.

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
#10 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 4 lines · Marc Zyngier

Peter said there is an undefined behaviour. I want to understand whether this is the case or not. QEMU is only one of the users of this stuff, as all the vendors have their own custom VMM, and they do things in funny ways.

It's not, as we don't special case this case in KVM_CLEAR_DIRTY_LOG. If that's confusing, we can drop it in the document. Thanks.

Signature · 1 line
Peter Xu
maintainer
#11 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

In reply to Peter Xu
Quoted 32 lines · Peter Xu
Quoted 30 lines · Marc Zyngier

Hi Peter,

Quoted 11 lines · Peter Xu

Hi, Marc,

Quoted 6 lines · Marc Zyngier

Review

Quoted 2 lines
(quoted diff) +2 -0
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Quoted 8 lines

The thing is the current with-bitmap design assumes that the two logs are collected in different windows of migration, while the dirty log is only collected after the VM is stopped. So collecting dirty bitmap and sending the dirty pages within the bitmap will be part of the VM downtime.

It will stop to make sense if the dirty bitmap can contain a large portion of the guest memory, because then it'll be simpler to just stop the VM, transfer pages, and restart on dest node without any tracking mechanism.

Oh, I absolutely agree that the whole vcpu dirty ring makes zero sense in general. It only makes sense if the source of the dirty pages is limited to the vcpus, which is literally a corner case. Look at any real machine, and you'll quickly realise that this isn't the case, and that DMA *is* a huge source of dirty pages.

Quoted 8 lines
Quoted 5 lines

Here, we're just lucky enough not to have much DMA tracking yet. Once that happens (and I have it from people doing the actual work that it *is* happening), you'll realise that the dirty ring story is of very limited use. So I'd rather drop anything quantitative here, as this is likely to be wrong.

Is it a must that arm64 needs to track device DMAs using the same dirty tracking interface rather than VFIO or any other interface?

What does it change? At the end of the day, you want a list of dirty pages. How you obtain it is irrelevant.

Quoted 4 lines

It's
definitely not the case for x86, but if it's true for arm64, then could the DMA be spread across all the guest pages? If it's also true, I really don't know how this will work..

Of course, all pages can be the target of DMA. It works the same way it works for the ITS: you sync the state, you obtain the dirty bits, you move on.

And mimicking what x86 does is really not my concern (if you still think that arm64 is just another flavour of x86, stay tuned! ;-).

Quoted 5 lines

We're only syncing the dirty bitmap once right now with the protocol. If that can cover most of the guest mem, it's same as non-live. If we sync it periodically, then it's the same as enabling dirty-log alone and the rings are useless.

I'm glad that you finally accept it: the ring *ARE* useless in the general sense. Only limited, CPU-only workloads can make any use of the current design. This probably covers a large proportion of what the cloud vendors do, but this doesn't work for general situations where you have a stream of dirty pages originating outside of the CPUs.

[...]

Quoted 11 lines
Quoted 10 lines
Quoted 6 lines

I wanted to make it clear that we don't need CLEAR_LOG at all in this case, as fundamentally clear log is about re-protect the guest pages, but if we're with the restriction of above (having the dirty bmap the last to collect and once and for all) then it'll make no sense to protect the guest page at all at this stage since src host shouldn't run after the GET_LOG then the CLEAR_LOG will be a vain effort.

That's not for you to decide, but userspace. I can perfectly expect userspace saving an ITS, getting the bitmap, saving the pages and then *clearing the log* before processing the next ITS. Or anything else.

Quoted 5 lines

I think I can get your point on why you're not happy with the document, but IMHO how we document is one thing, how it'll work is another. I preferred explicit documentation because it'll help the app developer to support the interface, also more docs to reference in the future; no strong opinion, though.

Here's my beef with the current documentation: it sets quantitative expectations. This is wrong. It also introduces undefined behaviours where there should be none. This is even worse, because there shouldn't be *any* undefined behaviour today, and I cannot see why the dirty rings would influence this.

Quoted 2 lines

However if there's fundamental statement that was literally wrong, then it's another thing, and we may need to rethink.

See above. If the undefined behaviour was just a mistake, let's drop it and move on. If you have spotted something that is indeed an undefined behaviour in using CLEAR_LOG when the VM is stopped, then live migration is already broken on arm64 *today*.

And if that's the case, we should fix it now instead of adding the dirty ring stuff.

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
#12 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 51 lines · Marc Zyngier
Quoted 32 lines · Peter Xu
Quoted 30 lines · Marc Zyngier

Hi Peter,

Quoted 11 lines · Peter Xu

Hi, Marc,

Quoted 6 lines · Marc Zyngier

Review

Quoted 2 lines
(quoted diff) +2 -0
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Quoted 8 lines

The thing is the current with-bitmap design assumes that the two logs are collected in different windows of migration, while the dirty log is only collected after the VM is stopped. So collecting dirty bitmap and sending the dirty pages within the bitmap will be part of the VM downtime.

It will stop to make sense if the dirty bitmap can contain a large portion of the guest memory, because then it'll be simpler to just stop the VM, transfer pages, and restart on dest node without any tracking mechanism.

Oh, I absolutely agree that the whole vcpu dirty ring makes zero sense in general. It only makes sense if the source of the dirty pages is limited to the vcpus, which is literally a corner case. Look at any real machine, and you'll quickly realise that this isn't the case, and that DMA *is* a huge source of dirty pages.

Quoted 8 lines
Quoted 5 lines

Here, we're just lucky enough not to have much DMA tracking yet. Once that happens (and I have it from people doing the actual work that it *is* happening), you'll realise that the dirty ring story is of very limited use. So I'd rather drop anything quantitative here, as this is likely to be wrong.

Is it a must that arm64 needs to track device DMAs using the same dirty tracking interface rather than VFIO or any other interface?

What does it change? At the end of the day, you want a list of dirty pages. How you obtain it is irrelevant.

Quoted 4 lines

It's
definitely not the case for x86, but if it's true for arm64, then could the DMA be spread across all the guest pages? If it's also true, I really don't know how this will work..

Quoted 6 lines

Of course, all pages can be the target of DMA. It works the same way it works for the ITS: you sync the state, you obtain the dirty bits, you move on.

And mimicking what x86 does is really not my concern (if you still think that arm64 is just another flavour of x86, stay tuned! ;-).

I didn't mean so, I should probably stop mentioning x86. :)

I had some sense already from the topics in past few years of kvm forum. Yeah I'll be looking forward to anything more coming.

Quoted 7 lines
Quoted 6 lines

We're only syncing the dirty bitmap once right now with the protocol. If that can cover most of the guest mem, it's same as non-live. If we sync it periodically, then it's the same as enabling dirty-log alone and the rings are useless.

Quoted 6 lines

I'm glad that you finally accept it: the ring *ARE* useless in the general sense. Only limited, CPU-only workloads can make any use of the current design. This probably covers a large proportion of what the cloud vendors do, but this doesn't work for general situations where you have a stream of dirty pages originating outside of the CPUs.

The ring itself is really not the thing to blame, IMHO it's a good attempt to try out de-coupling guest size in regard of dirty tracking from kvm. It may not be perfect, but it may still service some of the goals, e.g., at least it allows the user app to detect per-vcpu information and also since there's the ring full events we can do something more than before like the vcpu throttling that China Telecom does with the ring structures.

But I agree it's not a generic enough solution. Hopefully it'll still cover some use cases so it's not completely not making sense.

Thanks,

Signature · 1 line
Peter Xu
maintainer
#13 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 9 lines · Peter Xu
Quoted 7 lines · Marc Zyngier
Quoted 4 lines · Peter Xu

It's definitely not the case for x86, but if it's true for arm64, then could the DMA be spread across all the guest pages? If it's also true, I really don't know how this will work..

Quoted 8 lines
Quoted 6 lines

Of course, all pages can be the target of DMA. It works the same way it works for the ITS: you sync the state, you obtain the dirty bits, you move on.

And mimicking what x86 does is really not my concern (if you still think that arm64 is just another flavour of x86, stay tuned! ;-).

I didn't mean so, I should probably stop mentioning x86. :)

Please! I turned off my last x86 development machine over the weekend, and my x86 laptop is now a glorified window manager... ;-)

Quoted 2 lines

I had some sense already from the topics in past few years of kvm forum. Yeah I'll be looking forward to anything more coming.

Yup. Hopefully we won't have to wait for too long to see this stuff (I had good discussions on the subject at both KF and Plumbers in Dublin earlier this year).

Quoted 12 lines
Quoted 11 lines
Quoted 4 lines

We're only syncing the dirty bitmap once right now with the protocol. If that can cover most of the guest mem, it's same as non-live. If we sync it periodically, then it's the same as enabling dirty-log alone and the rings are useless.

I'm glad that you finally accept it: the ring *ARE* useless in the general sense. Only limited, CPU-only workloads can make any use of the current design. This probably covers a large proportion of what the cloud vendors do, but this doesn't work for general situations where you have a stream of dirty pages originating outside of the CPUs.

Quoted 6 lines

The ring itself is really not the thing to blame, IMHO it's a good attempt to try out de-coupling guest size in regard of dirty tracking from kvm. It may not be perfect, but it may still service some of the goals, e.g., at least it allows the user app to detect per-vcpu information and also since there's the ring full events we can do something more than before like the vcpu throttling that China Telecom does with the ring structures.

I don't disagree with that: for vcpu-based workloads, the rings are great and doing their job. It's just that there is another side to this problem, and you'll have to deal with both eventually. We're just ahead of the curve here...

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author
#14 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

In reply to Marc Zyngier

Hi Marc,

Quoted 56 lines · Marc Zyngier
Quoted 54 lines · Gavin Shan

ARM64 needs to dirty memory outside of a VCPU context when VGIC/ITS is enabled. It's conflicting with that ring-based dirty page tracking always requires a running VCPU context.

Introduce a new flavor of dirty ring that requires the use of both VCPU dirty rings and a dirty bitmap. The expectation is that for non-VCPU sources of dirty memory (such as the VGIC/ITS on arm64), KVM writes to the dirty bitmap. Userspace should scan the dirty bitmap before migrating the VM to the target.

Use an additional capability to advertise this behavior. The newly added capability (KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP) can't be enabled before KVM_CAP_DIRTY_LOG_RING_ACQ_REL on ARM64. In this way, the newly added capability is treated as an extension of KVM_CAP_DIRTY_LOG_RING_ACQ_REL.

---
  Documentation/virt/kvm/api.rst | 33 ++++++++++++++++++-----
  include/linux/kvm_dirty_ring.h |  7 +++++
  include/linux/kvm_host.h       |  1 +
  include/uapi/linux/kvm.h       |  1 +
  virt/kvm/Kconfig               |  8 ++++++
  virt/kvm/dirty_ring.c          | 10 +++++++
  virt/kvm/kvm_main.c            | 49 +++++++++++++++++++++++++++-------
  7 files changed, 93 insertions(+), 16 deletions(-)
Documentation/virt/kvm/api.rst +0 -7
index eee9f857a986..2ec32bd41792 100644
@@ -8003,13 +8003,6 @@ flushing is done by the KVM_GET_DIRTY_LOG ioctl).  To achieve that, one
  needs to kick the vcpu out of KVM_RUN using a signal.  The resulting
  vmexit ensures that all dirty GFNs are flushed to the dirty rings.
 
-NOTE: the capability KVM_CAP_DIRTY_LOG_RING and the corresponding
-ioctl KVM_RESET_DIRTY_RINGS are mutual exclusive to the existing ioctls
-KVM_GET_DIRTY_LOG and KVM_CLEAR_DIRTY_LOG.  After enabling
-KVM_CAP_DIRTY_LOG_RING with an acceptable dirty ring size, the virtual
-machine will switch to ring-buffer dirty page tracking and further
-KVM_GET_DIRTY_LOG or KVM_CLEAR_DIRTY_LOG ioctls will fail.
-
  NOTE: KVM_CAP_DIRTY_LOG_RING_ACQ_REL is the only capability that
  should be exposed by weakly ordered architecture, in order to indicate
  the additional memory ordering requirements imposed on userspace when
@@ -8018,6 +8011,32 @@ Architecture with TSO-like ordering (such as x86) are allowed to
  expose both KVM_CAP_DIRTY_LOG_RING and KVM_CAP_DIRTY_LOG_RING_ACQ_REL
  to userspace.
 
Quoted 4 lines

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8014

Quoted 1 line
Documentation/virt/kvm/api.rst +1 -0
+After using the dirty rings, the userspace needs to detect the capability

using? or enabling? What comes after suggest the latter.

s/using/enabling in next revision :)

Quoted 6 lines

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8017

Quoted 3 lines
Documentation/virt/kvm/api.rst +3 -0
+of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures
+need to be backed by per-slot bitmaps. With this capability advertised
+and supported, it means the architecture can dirty guest pages without

If it is advertised, it is supported, right?

Yes, s/advertised and supported/advertised in next revision.

Quoted 12 lines

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8024

Quoted 7 lines
Documentation/virt/kvm/api.rst +7 -0
+vcpu/ring context, so that some of the dirty information will still be
+maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP
+can't be enabled until the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL
+has been enabled.
+
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

It's the pre-requisite to use the backup bitmap. Otherwise, the guest will experience long down-time during migration, as mentioned by Peter in another thread. So it's appropriate to mention the limit of dirty pages here.

Quoted 8 lines
Quoted 8 lines
Documentation/virt/kvm/api.rst +8 -0
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
Quoted 9 lines

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8034

Quoted 2 lines
Documentation/virt/kvm/api.rst +2 -0
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.

It isn't clear to me why KVM_CLEAR_DIRTY_LOG should be called out. If you have multiple devices that dirty the memory, such as multiple ITSs, why shouldn't userspace be allowed to snapshot the dirty state multiple time? This doesn't seem like a reasonable restriction, and I really dislike the idea of undefined behaviour here.

It was actually documenting the expected QEMU's usage. With QEMU excluded, KVM_CLEAR_DIRTY_LOG can be used as usual. Undefined behavior seems not precise here. We can improve it like below, to avoid talking about 'undefined behaviour'.

To collect dirty bits in the backup bitmap, the userspace can use the same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed since collecting the dirty bitmap always happens in the last phase of VM's migration.

Quoted 15 lines

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8038

Quoted 4 lines
Documentation/virt/kvm/api.rst +4 -0
+
+NOTE: One example of using the backup bitmap is saving arm64 vgic/its
+tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on
+KVM device "kvm-arm-vgic-its" during VM's migration.

It would be good to have something about this in the ITS documentation. Something along these lines:

Documentation/virt/kvm/devices/arm-vgic-its.rst +0 -0
index d257eddbae29..e053124f77c4 100644
@@ -52,7 +52,10 @@ KVM_DEV_ARM_VGIC_GRP_CTRL
 

Documentation/virt/kvm/devices/arm-vgic-its.rst KVM_DEV_ARM_VGIC_GRP_CTRL · line 61

Quoted 10 lines
Documentation/virt/kvm/devices/arm-vgic-its.rst +4 -1
      KVM_DEV_ARM_ITS_SAVE_TABLES
        save the ITS table data into guest RAM, at the location provisioned
-      by the guest in corresponding registers/table entries.
+      by the guest in corresponding registers/table entries. Should userspace
+      require a form of dirty tracking to identify which pages are modified
+      by the saving process, it should use a bitmap even if using another
+      mechanism to track the memory dirtied by the vCPUs.
 
        The layout of the tables in guest memory defines an ABI. The entries
        are laid out in little endian format as described in the last paragraph.

Sure, I will have it in next revision.

Quoted 186 lines
Quoted 186 lines
Documentation/virt/kvm/api.rst +1 -0
+
  8.30 KVM_CAP_XEN_HVM
  --------------------
 
include/linux/kvm_dirty_ring.h +7 -0
index 199ead37b104..4862c98d80d3 100644
@@ -37,6 +37,11 @@ static inline u32 kvm_dirty_ring_get_rsvd_entries(void)
  	return 0;
  }
 
+static inline bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
+	return true;
+}
+
  static inline int kvm_dirty_ring_alloc(struct kvm_dirty_ring *ring,
  				       int index, u32 size)
  {
@@ -67,6 +72,8 @@ static inline void kvm_dirty_ring_free(struct kvm_dirty_ring *ring)
  #else /* CONFIG_HAVE_KVM_DIRTY_RING */
 
  int kvm_cpu_dirty_log_size(void);
+bool kvm_use_dirty_bitmap(struct kvm *kvm);
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm);
  u32 kvm_dirty_ring_get_rsvd_entries(void);
  int kvm_dirty_ring_alloc(struct kvm_dirty_ring *ring, int index, u32 size);
 
include/linux/kvm_host.h +1 -0
index 6fab55e58111..f51eb9419bfc 100644
@@ -779,6 +779,7 @@ struct kvm {
  	pid_t userspace_pid;
  	unsigned int max_halt_poll_ns;
  	u32 dirty_ring_size;
+	bool dirty_ring_with_bitmap;
  	bool vm_bugged;
  	bool vm_dead;
 
include/uapi/linux/kvm.h +1 -0
index 0d5d4419139a..c87b5882d7ae 100644
@@ -1178,6 +1178,7 @@ struct kvm_ppc_resize_hpt {
  #define KVM_CAP_S390_ZPCI_OP 221
  #define KVM_CAP_S390_CPU_TOPOLOGY 222
  #define KVM_CAP_DIRTY_LOG_RING_ACQ_REL 223
+#define KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP 224
 
  #ifdef KVM_CAP_IRQ_ROUTING
 
virt/kvm/Kconfig +8 -0
index 800f9470e36b..228be1145cf3 100644
@@ -33,6 +33,14 @@ config HAVE_KVM_DIRTY_RING_ACQ_REL
         bool
         select HAVE_KVM_DIRTY_RING
 
+# Only architectures that need to dirty memory outside of a vCPU
+# context should select this, advertising to userspace the
+# requirement to use a dirty bitmap in addition to the vCPU dirty
+# ring.
+config HAVE_KVM_DIRTY_RING_WITH_BITMAP
+	bool
+	depends on HAVE_KVM_DIRTY_RING
+
  config HAVE_KVM_EVENTFD
         bool
         select EVENTFD
virt/kvm/dirty_ring.c +10 -0
index fecbb7d75ad2..758679724447 100644
@@ -21,6 +21,16 @@ u32 kvm_dirty_ring_get_rsvd_entries(void)
  	return KVM_DIRTY_RING_RSVD_ENTRIES + kvm_cpu_dirty_log_size();
  }
 
+bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
+	return !kvm->dirty_ring_size || kvm->dirty_ring_with_bitmap;
+}
+
+bool __weak kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return false;
+}
+
  static u32 kvm_dirty_ring_used(struct kvm_dirty_ring *ring)
  {
  	return READ_ONCE(ring->dirty_index) - READ_ONCE(ring->reset_index);
virt/kvm/kvm_main.c +26 -9
index c865d7d82685..746133b23a66 100644
@@ -1617,7 +1617,7 @@ static int kvm_prepare_memory_region(struct kvm *kvm,
  			new->dirty_bitmap = NULL;
  		else if (old && old->dirty_bitmap)
  			new->dirty_bitmap = old->dirty_bitmap;
-		else if (!kvm->dirty_ring_size) {
+		else if (kvm_use_dirty_bitmap(kvm)) {
  			r = kvm_alloc_dirty_bitmap(new);
  			if (r)
  				return r;
@@ -2060,8 +2060,8 @@ int kvm_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log,
  	unsigned long n;
  	unsigned long any = 0;
 
-	/* Dirty ring tracking is exclusive to dirty log tracking */
-	if (kvm->dirty_ring_size)
+	/* Dirty ring tracking may be exclusive to dirty log tracking */
+	if (!kvm_use_dirty_bitmap(kvm))
  		return -ENXIO;
 
  	*memslot = NULL;
@@ -2125,8 +2125,8 @@ static int kvm_get_dirty_log_protect(struct kvm *kvm, struct kvm_dirty_log *log)
  	unsigned long *dirty_bitmap_buffer;
  	bool flush;
 
-	/* Dirty ring tracking is exclusive to dirty log tracking */
-	if (kvm->dirty_ring_size)
+	/* Dirty ring tracking may be exclusive to dirty log tracking */
+	if (!kvm_use_dirty_bitmap(kvm))
  		return -ENXIO;
 
  	as_id = log->slot >> 16;
@@ -2237,8 +2237,8 @@ static int kvm_clear_dirty_log_protect(struct kvm *kvm,
  	unsigned long *dirty_bitmap_buffer;
  	bool flush;
 
-	/* Dirty ring tracking is exclusive to dirty log tracking */
-	if (kvm->dirty_ring_size)
+	/* Dirty ring tracking may be exclusive to dirty log tracking */
+	if (!kvm_use_dirty_bitmap(kvm))
  		return -ENXIO;
 
  	as_id = log->slot >> 16;
@@ -3305,7 +3305,10 @@ void mark_page_dirty_in_slot(struct kvm *kvm,
  	struct kvm_vcpu *vcpu = kvm_get_running_vcpu();
 
  #ifdef CONFIG_HAVE_KVM_DIRTY_RING
-	if (WARN_ON_ONCE(!vcpu) || WARN_ON_ONCE(vcpu->kvm != kvm))
+	if (WARN_ON_ONCE(vcpu && vcpu->kvm != kvm))
+		return;
+
+	if (WARN_ON_ONCE(!kvm_arch_allow_write_without_running_vcpu(kvm) && !vcpu))
  		return;
  #endif
 
@@ -3313,7 +3316,7 @@ void mark_page_dirty_in_slot(struct kvm *kvm,
  		unsigned long rel_gfn = gfn - memslot->base_gfn;
  		u32 slot = (memslot->as_id << 16) | memslot->id;
 
-		if (kvm->dirty_ring_size)
+		if (kvm->dirty_ring_size && vcpu)
  			kvm_dirty_ring_push(vcpu, slot, rel_gfn);
  		else
  			set_bit_le(rel_gfn, memslot->dirty_bitmap);
@@ -4482,6 +4485,9 @@ static long kvm_vm_ioctl_check_extension_generic(struct kvm *kvm, long arg)
  		return KVM_DIRTY_RING_MAX_ENTRIES * sizeof(struct kvm_dirty_gfn);
  #else
  		return 0;
+#endif
+#ifdef CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP
+	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP:
  #endif
  	case KVM_CAP_BINARY_STATS_FD:
  	case KVM_CAP_SYSTEM_EVENT_DATA:
@@ -4588,6 +4594,31 @@ static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
  			return -EINVAL;
 
  		return kvm_vm_ioctl_enable_dirty_log_ring(kvm, cap->args[0]);
+	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP: {
+		struct kvm_memslots *slots;
+		int r = -EINVAL;
+
+		if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
+		    !kvm->dirty_ring_size)
+			return r;
+
+		mutex_lock(&kvm->slots_lock);
+
+		slots = kvm_memslots(kvm);
Quoted 9 lines

virt/kvm/kvm_main.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4612

Quoted 5 lines
virt/kvm/kvm_main.c +5 -0
+
+		/*
+		 * Avoid a race between memslot creation and enabling the ring +
+		 * bitmap capability to guarantee that no memslots have been
+		 * created without a bitmap.

It should be called out in the documentation that this capability must be enabled before any memslot is created.

Right, Will do in next revision.

Quoted 4 lines
Quoted 4 lines
virt/kvm/kvm_main.c +4 -0
+		 */
+		if (kvm_memslots_empty(slots)) {
+			kvm->dirty_ring_with_bitmap = cap->args[0];
+			r = 0;
Quoted 8 lines

virt/kvm/kvm_main.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4624

Quoted 8 lines
virt/kvm/kvm_main.c +5 -0
+		}
+
+		mutex_unlock(&kvm->slots_lock);
+		return r;
+	}
  	default:
  		return kvm_vm_ioctl_enable_cap(kvm, cap);
  	}

Thanks,
Gavin

maintainer
#15 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 89 lines · Gavin Shan

Hi Marc,

Quoted 51 lines · Marc Zyngier
Quoted 49 lines · Gavin Shan

ARM64 needs to dirty memory outside of a VCPU context when VGIC/ITS is enabled. It's conflicting with that ring-based dirty page tracking always requires a running VCPU context.

Introduce a new flavor of dirty ring that requires the use of both VCPU dirty rings and a dirty bitmap. The expectation is that for non-VCPU sources of dirty memory (such as the VGIC/ITS on arm64), KVM writes to the dirty bitmap. Userspace should scan the dirty bitmap before migrating the VM to the target.

Use an additional capability to advertise this behavior. The newly added capability (KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP) can't be enabled before KVM_CAP_DIRTY_LOG_RING_ACQ_REL on ARM64. In this way, the newly added capability is treated as an extension of KVM_CAP_DIRTY_LOG_RING_ACQ_REL.

---
  Documentation/virt/kvm/api.rst | 33 ++++++++++++++++++-----
  include/linux/kvm_dirty_ring.h |  7 +++++
  include/linux/kvm_host.h       |  1 +
  include/uapi/linux/kvm.h       |  1 +
  virt/kvm/Kconfig               |  8 ++++++
  virt/kvm/dirty_ring.c          | 10 +++++++
  virt/kvm/kvm_main.c            | 49 +++++++++++++++++++++++++++-------
  7 files changed, 93 insertions(+), 16 deletions(-)
Documentation/virt/kvm/api.rst +0 -0
index eee9f857a986..2ec32bd41792 100644
@@ -8003,13 +8003,6 @@ flushing is done by the KVM_GET_DIRTY_LOG ioctl).  To achieve that, one
  needs to kick the vcpu out of KVM_RUN using a signal.  The resulting
  vmexit ensures that all dirty GFNs are flushed to the dirty rings.
  -NOTE: the capability KVM_CAP_DIRTY_LOG_RING and the

corresponding

Documentation/virt/kvm/api.rst +0 -6
-ioctl KVM_RESET_DIRTY_RINGS are mutual exclusive to the existing ioctls
-KVM_GET_DIRTY_LOG and KVM_CLEAR_DIRTY_LOG.  After enabling
-KVM_CAP_DIRTY_LOG_RING with an acceptable dirty ring size, the virtual
-machine will switch to ring-buffer dirty page tracking and further
-KVM_GET_DIRTY_LOG or KVM_CLEAR_DIRTY_LOG ioctls will fail.
-
  NOTE: KVM_CAP_DIRTY_LOG_RING_ACQ_REL is the only capability that
  should be exposed by weakly ordered architecture, in order to indicate
Quoted 9 lines
Quoted 6 lines

the additional memory ordering requirements imposed on userspace when

Documentation/virt/kvm/api.rst +0 -0
@@ -8018,6 +8011,32 @@ Architecture with TSO-like ordering (such as x86) are allowed to
  expose both KVM_CAP_DIRTY_LOG_RING and KVM_CAP_DIRTY_LOG_RING_ACQ_REL
  to userspace.
  +After using the dirty rings, the userspace needs to detect the

capability

using? or enabling? What comes after suggest the latter.

s/using/enabling in next revision :)

Quoted 6 lines

Documentation/virt/kvm/api.rst

Quoted 3 lines
Documentation/virt/kvm/api.rst +3 -0
+of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures
+need to be backed by per-slot bitmaps. With this capability advertised
+and supported, it means the architecture can dirty guest pages without

If it is advertised, it is supported, right?

Yes, s/advertised and supported/advertised in next revision.

Quoted 12 lines

Documentation/virt/kvm/api.rst

Quoted 7 lines
Documentation/virt/kvm/api.rst +7 -0
+vcpu/ring context, so that some of the dirty information will still be
+maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP
+can't be enabled until the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL
+has been enabled.
+
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which

I don't think we can claim this. It is whatever amount of memory is dirtied outside of a vcpu context, and we shouldn't make any claim regarding the number of dirty pages.

Quoted 4 lines

It's the pre-requisite to use the backup bitmap. Otherwise, the guest will experience long down-time during migration, as mentioned by Peter in another thread. So it's appropriate to mention the limit of dirty pages here.

See my alternative wording for this in the other sub-thread.

Quoted 24 lines
Quoted 18 lines

Documentation/virt/kvm/api.rst

Quoted 11 lines
Documentation/virt/kvm/api.rst +10 -0
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.

It isn't clear to me why KVM_CLEAR_DIRTY_LOG should be called out. If you have multiple devices that dirty the memory, such as multiple ITSs, why shouldn't userspace be allowed to snapshot the dirty state multiple time? This doesn't seem like a reasonable restriction, and I really dislike the idea of undefined behaviour here.

It was actually documenting the expected QEMU's usage. With QEMU excluded, KVM_CLEAR_DIRTY_LOG can be used as usual. Undefined behavior seems not precise here. We can improve it like below, to avoid talking about 'undefined behaviour'.

Quoted 4 lines

To collect dirty bits in the backup bitmap, the userspace can use the same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed since collecting the dirty bitmap always happens in the last phase of VM's migration.

That's better, but the "shouldn't be needed" wording makes things ambiguous, and we shouldn't mention migration at all (this is not the only purpose of this API). I'd suggest this:

To collect dirty bits in the backup bitmap, userspace can use the same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG isn't needed as long as all the generation of the dirty bits is done in a single pass.

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author
#16 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

In reply to Gavin Shan

Hi Marc, Peter, Oliver and Sean,

Quoted 69 lines · Gavin Shan

ARM64 needs to dirty memory outside of a VCPU context when VGIC/ITS is enabled. It's conflicting with that ring-based dirty page tracking always requires a running VCPU context.

Introduce a new flavor of dirty ring that requires the use of both VCPU dirty rings and a dirty bitmap. The expectation is that for non-VCPU sources of dirty memory (such as the VGIC/ITS on arm64), KVM writes to the dirty bitmap. Userspace should scan the dirty bitmap before migrating the VM to the target.

Use an additional capability to advertise this behavior. The newly added capability (KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP) can't be enabled before KVM_CAP_DIRTY_LOG_RING_ACQ_REL on ARM64. In this way, the newly added capability is treated as an extension of KVM_CAP_DIRTY_LOG_RING_ACQ_REL.

---
  Documentation/virt/kvm/api.rst | 33 ++++++++++++++++++-----
  include/linux/kvm_dirty_ring.h |  7 +++++
  include/linux/kvm_host.h       |  1 +
  include/uapi/linux/kvm.h       |  1 +
  virt/kvm/Kconfig               |  8 ++++++
  virt/kvm/dirty_ring.c          | 10 +++++++
  virt/kvm/kvm_main.c            | 49 +++++++++++++++++++++++++++-------
  7 files changed, 93 insertions(+), 16 deletions(-)
Documentation/virt/kvm/api.rst +16 -7
index eee9f857a986..2ec32bd41792 100644
@@ -8003,13 +8003,6 @@ flushing is done by the KVM_GET_DIRTY_LOG ioctl).  To achieve that, one
  needs to kick the vcpu out of KVM_RUN using a signal.  The resulting
  vmexit ensures that all dirty GFNs are flushed to the dirty rings.
 
-NOTE: the capability KVM_CAP_DIRTY_LOG_RING and the corresponding
-ioctl KVM_RESET_DIRTY_RINGS are mutual exclusive to the existing ioctls
-KVM_GET_DIRTY_LOG and KVM_CLEAR_DIRTY_LOG.  After enabling
-KVM_CAP_DIRTY_LOG_RING with an acceptable dirty ring size, the virtual
-machine will switch to ring-buffer dirty page tracking and further
-KVM_GET_DIRTY_LOG or KVM_CLEAR_DIRTY_LOG ioctls will fail.
-
  NOTE: KVM_CAP_DIRTY_LOG_RING_ACQ_REL is the only capability that
  should be exposed by weakly ordered architecture, in order to indicate
  the additional memory ordering requirements imposed on userspace when
@@ -8018,6 +8011,32 @@ Architecture with TSO-like ordering (such as x86) are allowed to
  expose both KVM_CAP_DIRTY_LOG_RING and KVM_CAP_DIRTY_LOG_RING_ACQ_REL
  to userspace.
 
+After using the dirty rings, the userspace needs to detect the capability
+of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures
+need to be backed by per-slot bitmaps. With this capability advertised
+and supported, it means the architecture can dirty guest pages without
+vcpu/ring context, so that some of the dirty information will still be
+maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP
+can't be enabled until the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL
+has been enabled.
+
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8039

Quoted 10 lines
Documentation/virt/kvm/api.rst +10 -0
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.
+
+NOTE: One example of using the backup bitmap is saving arm64 vgic/its
+tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on
+KVM device "kvm-arm-vgic-its" during VM's migration.
+

In order to speed up the review and reduce unnecessary respins. After collecting comments on PATCH[v8 3/7] from Marc and Peter, I would change above description as below. Could you please confirm it looks good to you?

In the 4th paragraph, the words starting from "Collecting the dirty bitmap..." to the end, was previously suggested by Oliver, even Marc suggested to avoid mentioning "migration".

After enabling the dirty rings, the userspace needs to detect the capability of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures need to be backed by per-slot bitmaps. With this capability advertised, it means the architecture can dirty guest pages without vcpu/ring context, so that some of the dirty information will still be maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP can't be enabled if the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL hasn't been enabled, or any memslot has been existing.

Note that the bitmap here is only a backup of the ring structure. The use of the ring and bitmap combination is only beneficial if there is only a very small amount of memory that is dirtied out of vcpu/ring context. Otherwise, the stand-alone per-slot bitmap mechanism needs to be considered.

To collect dirty bits in the backup bitmap, userspace can use the same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG isn't needed as long as all the generation of the dirty bits is done in a single pass. Collecting the dirty bitmap should be the very last thing that the VMM does before transmitting state to the target VM. VMM needs to ensure that the dirty state is final and avoid missing dirty pages from another ioctl ordered after the bitmap collection.

NOTE: One example of using the backup bitmap is saving arm64 vgic/its tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on KVM device "kvm-arm-vgic-its" during VM's migration.

Thanks,
Gavin

maintainer
#17 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 87 lines · Gavin Shan

Hi Marc, Peter, Oliver and Sean,

Quoted 68 lines · Gavin Shan

ARM64 needs to dirty memory outside of a VCPU context when VGIC/ITS is enabled. It's conflicting with that ring-based dirty page tracking always requires a running VCPU context.

Introduce a new flavor of dirty ring that requires the use of both VCPU dirty rings and a dirty bitmap. The expectation is that for non-VCPU sources of dirty memory (such as the VGIC/ITS on arm64), KVM writes to the dirty bitmap. Userspace should scan the dirty bitmap before migrating the VM to the target.

Use an additional capability to advertise this behavior. The newly added capability (KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP) can't be enabled before KVM_CAP_DIRTY_LOG_RING_ACQ_REL on ARM64. In this way, the newly added capability is treated as an extension of KVM_CAP_DIRTY_LOG_RING_ACQ_REL.

---
  Documentation/virt/kvm/api.rst | 33 ++++++++++++++++++-----
  include/linux/kvm_dirty_ring.h |  7 +++++
  include/linux/kvm_host.h       |  1 +
  include/uapi/linux/kvm.h       |  1 +
  virt/kvm/Kconfig               |  8 ++++++
  virt/kvm/dirty_ring.c          | 10 +++++++
  virt/kvm/kvm_main.c            | 49 +++++++++++++++++++++++++++-------
  7 files changed, 93 insertions(+), 16 deletions(-)
Documentation/virt/kvm/api.rst +0 -6
index eee9f857a986..2ec32bd41792 100644
@@ -8003,13 +8003,6 @@ flushing is done by the KVM_GET_DIRTY_LOG ioctl).  To achieve that, one
  needs to kick the vcpu out of KVM_RUN using a signal.  The resulting
  vmexit ensures that all dirty GFNs are flushed to the dirty rings.
  -NOTE: the capability KVM_CAP_DIRTY_LOG_RING and the corresponding
-ioctl KVM_RESET_DIRTY_RINGS are mutual exclusive to the existing ioctls
-KVM_GET_DIRTY_LOG and KVM_CLEAR_DIRTY_LOG.  After enabling
-KVM_CAP_DIRTY_LOG_RING with an acceptable dirty ring size, the virtual
-machine will switch to ring-buffer dirty page tracking and further
-KVM_GET_DIRTY_LOG or KVM_CLEAR_DIRTY_LOG ioctls will fail.
-
  NOTE: KVM_CAP_DIRTY_LOG_RING_ACQ_REL is the only capability that
  should be exposed by weakly ordered architecture, in order to indicate
  the additional memory ordering requirements imposed on userspace when
@@ -8018,6 +8011,32 @@ Architecture with TSO-like ordering (such as x86) are allowed to
  expose both KVM_CAP_DIRTY_LOG_RING and KVM_CAP_DIRTY_LOG_RING_ACQ_REL
  to userspace.
  +After using the dirty rings, the userspace needs to detect the

capability

Documentation/virt/kvm/api.rst +15 -0
+of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures
+need to be backed by per-slot bitmaps. With this capability advertised
+and supported, it means the architecture can dirty guest pages without
+vcpu/ring context, so that some of the dirty information will still be
+maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP
+can't be enabled until the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL
+has been enabled.
+
+Note that the bitmap here is only a backup of the ring structure, and
+normally should only contain a very small amount of dirty pages, which
+needs to be transferred during VM downtime. Collecting the dirty bitmap
+should be the very last thing that the VMM does before transmitting state
+to the target VM. VMM needs to ensure that the dirty state is final and
+avoid missing dirty pages from another ioctl ordered after the bitmap
+collection.

Documentation/virt/kvm/api.rst Architecture with TSO-like ordering (such as x86) are allowed to · line 8039

Quoted 10 lines
Documentation/virt/kvm/api.rst +10 -0
+
+To collect dirty bits in the backup bitmap, the userspace can use the
+same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG shouldn't be needed
+and its behavior is undefined since collecting the dirty bitmap always
+happens in the last phase of VM's migration.
+
+NOTE: One example of using the backup bitmap is saving arm64 vgic/its
+tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on
+KVM device "kvm-arm-vgic-its" during VM's migration.
+

In order to speed up the review and reduce unnecessary respins. After collecting comments on PATCH[v8 3/7] from Marc and Peter, I would change above description as below. Could you please confirm it looks good to you?

Quoted 7 lines

In the 4th paragraph, the words starting from "Collecting the dirty bitmap..." to the end, was previously suggested by Oliver, even Marc suggested to avoid mentioning "migration".

After enabling the dirty rings, the userspace needs to detect the capability of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures need to be backed by per-slot bitmaps. With this capability

s/need/can/. If there was a *need*, it should happen automatically without user intervention.

Quoted 12 lines

advertised, it means the architecture can dirty guest pages without vcpu/ring context, so that some of the dirty information will still be maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP can't be enabled if the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL hasn't been enabled, or any memslot has been existing.

Note that the bitmap here is only a backup of the ring structure. The use of the ring and bitmap combination is only beneficial if there is only a very small amount of memory that is dirtied out of vcpu/ring context. Otherwise, the stand-alone per-slot bitmap mechanism needs to be considered.

Quoted 7 lines

To collect dirty bits in the backup bitmap, userspace can use the same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG isn't needed as long as all the generation of the dirty bits is done in a single pass. Collecting the dirty bitmap should be the very last thing that the VMM does before transmitting state to the target VM. VMM needs to ensure that the dirty state is final and avoid missing dirty pages from another ioctl ordered after the bitmap collection.

I would replace "transmitting state to the target VM" with "considering the state as complete", as I still object to casting this API into the migration mold. People use this stuff more far more than migration (checkpointing, for example).

Quoted 4 lines

NOTE: One example of using the backup bitmap is saving arm64 vgic/its tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on KVM device "kvm-arm-vgic-its" during VM's migration.

Same remark about migration.

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author
#18 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Hi Marc,

Quoted 35 lines · Marc Zyngier
Quoted 33 lines · Gavin Shan
Quoted 32 lines · Gavin Shan

ARM64 needs to dirty memory outside of a VCPU context when VGIC/ITS is enabled. It's conflicting with that ring-based dirty page tracking always requires a running VCPU context.

Introduce a new flavor of dirty ring that requires the use of both VCPU dirty rings and a dirty bitmap. The expectation is that for non-VCPU sources of dirty memory (such as the VGIC/ITS on arm64), KVM writes to the dirty bitmap. Userspace should scan the dirty bitmap before migrating the VM to the target.

Use an additional capability to advertise this behavior. The newly added capability (KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP) can't be enabled before KVM_CAP_DIRTY_LOG_RING_ACQ_REL on ARM64. In this way, the newly added capability is treated as an extension of KVM_CAP_DIRTY_LOG_RING_ACQ_REL.

---
   Documentation/virt/kvm/api.rst | 33 ++++++++++++++++++-----
   include/linux/kvm_dirty_ring.h |  7 +++++
   include/linux/kvm_host.h       |  1 +
   include/uapi/linux/kvm.h       |  1 +
   virt/kvm/Kconfig               |  8 ++++++
   virt/kvm/dirty_ring.c          | 10 +++++++
   virt/kvm/kvm_main.c            | 49 +++++++++++++++++++++++++++-------
   7 files changed, 93 insertions(+), 16 deletions(-)
Documentation/virt/kvm/api.rst +0 -0

[...]

Quoted 9 lines
Quoted 9 lines

In order to speed up the review and reduce unnecessary respins. After collecting comments on PATCH[v8 3/7] from Marc and Peter, I would change above description as below. Could you please confirm it looks good to you?

In the 4th paragraph, the words starting from "Collecting the dirty bitmap..." to the end, was previously suggested by Oliver, even Marc suggested to avoid mentioning "migration".

Quoted 7 lines
Quoted 3 lines

After enabling the dirty rings, the userspace needs to detect the capability of KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP to see whether the ring structures need to be backed by per-slot bitmaps. With this capability

s/need/can/. If there was a *need*, it should happen automatically without user intervention.

Ok. s/need to/can in next revision :)

Quoted 20 lines
Quoted 12 lines

advertised, it means the architecture can dirty guest pages without vcpu/ring context, so that some of the dirty information will still be maintained in the bitmap structure. KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP can't be enabled if the capability of KVM_CAP_DIRTY_LOG_RING_ACQ_REL hasn't been enabled, or any memslot has been existing.

Note that the bitmap here is only a backup of the ring structure. The use of the ring and bitmap combination is only beneficial if there is only a very small amount of memory that is dirtied out of vcpu/ring context. Otherwise, the stand-alone per-slot bitmap mechanism needs to be considered.

Quoted 7 lines

To collect dirty bits in the backup bitmap, userspace can use the same KVM_GET_DIRTY_LOG ioctl. KVM_CLEAR_DIRTY_LOG isn't needed as long as all the generation of the dirty bits is done in a single pass. Collecting the dirty bitmap should be the very last thing that the VMM does before transmitting state to the target VM. VMM needs to ensure that the dirty state is final and avoid missing dirty pages from another ioctl ordered after the bitmap collection.

Quoted 5 lines

I would replace "transmitting state to the target VM" with "considering the state as complete", as I still object to casting this API into the migration mold. People use this stuff more far more than migration (checkpointing, for example).

Fair enough. I will change accordingly in next revision.

Quoted 7 lines
Quoted 4 lines

NOTE: One example of using the backup bitmap is saving arm64 vgic/its tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on KVM device "kvm-arm-vgic-its" during VM's migration.

Same remark about migration.

Ok. I will change this paragraph as below in next revision, to avoid mentioning "migration".

NOTE: One example of using the backup bitmap is saving arm64 vgic/its tables through KVM_DEV_ARM_{VGIC_GRP_CTRL, ITS_SAVE_TABLES} command on KVM device "kvm-arm-vgic-its" when dirty ring is enabled.

Thanks,
Gavin

#19 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

In reply to Gavin Shan

virt/kvm/dirty_ring.c u32 kvm_dirty_ring_get_rsvd_entries(void) · line 25

Quoted 10 lines · Gavin Shan
virt/kvm/dirty_ring.c +2 -0
index fecbb7d75ad2..758679724447 100644
@@ -21,6 +21,16 @@ u32 kvm_dirty_ring_get_rsvd_entries(void)
 	return KVM_DIRTY_RING_RSVD_ENTRIES + kvm_cpu_dirty_log_size();
 }
 
+bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
	lockdep_assert_held(&kvm->slots_lock);

To guard against accessing kvm->dirty_ring_with_bitmap without holding slots_lock.

Quoted 8 lines
virt/kvm/dirty_ring.c +4 -0
+	return !kvm->dirty_ring_size || kvm->dirty_ring_with_bitmap;
+}
+
@@ -4588,6 +4594,31 @@ static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
 			return -EINVAL;
 
 		return kvm_vm_ioctl_enable_dirty_log_ring(kvm, cap->args[0]);
+	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP: {

virt/kvm/dirty_ring.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4607

Quoted 10 lines
virt/kvm/dirty_ring.c +10 -0
+		struct kvm_memslots *slots;
+		int r = -EINVAL;
+
+		if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
+		    !kvm->dirty_ring_size)
+			return r;
+
+		mutex_lock(&kvm->slots_lock);
+
+		slots = kvm_memslots(kvm);

Sadly, this needs to iterate over all possible memslots thanks to x86's SMM address space. Might be worth adding a separate helper (that's local to kvm_main.c to discourage use), e.g.

static bool kvm_are_all_memslots_empty(struct kvm *kvm)

{
	int i;

	lockdep_assert_held(&kvm->slots_lock);

	for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
		if (!kvm_memslots_empty(__kvm_memslots(kvm, i)))
			return false;
	}

	return true;
}

virt/kvm/dirty_ring.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4612

Quoted 5 lines
virt/kvm/dirty_ring.c +5 -0
+
+		/*
+		 * Avoid a race between memslot creation and enabling the ring +
+		 * bitmap capability to guarantee that no memslots have been
+		 * created without a bitmap.

Nit, it's not just enabling, the below also allows disabling the bitmap. The enabling case is definitely the most interesting, but the above wording makes it sound like the enabling case is the only thing that being given protection. That's kinda true since KVM frees bitmaps without checking kvm_use_dirty_bitmap(), but that's not a strict requirement.

And there's no race required, e.g. without this check userspace could simply create a memslot and then toggle on the capability. Acquiring slots_lock above is what guards against races.

Might also be worth alluding to the alternative solution of allocating the bitmap for all memslots here, e.g. something like

/*
* For simplicity, allow toggling ring+bitmap if and only if
* there are no memslots, e.g. to ensure all memslots allocate a
* bitmap after the capability is enabled.
*/

Quoted 13 lines
virt/kvm/dirty_ring.c +9 -0
+		 */
+		if (kvm_memslots_empty(slots)) {
+			kvm->dirty_ring_with_bitmap = cap->args[0];
+			r = 0;
+		}
+
+		mutex_unlock(&kvm->slots_lock);
+		return r;
+	}
 	default:
 		return kvm_vm_ioctl_enable_cap(kvm, cap);
 	}
author
#20 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Hi Sean,

Quoted 9 lines · Sean Christopherson
Quoted 8 lines · Gavin Shan
virt/kvm/dirty_ring.c +0 -0
index fecbb7d75ad2..758679724447 100644
@@ -21,6 +21,16 @@ u32 kvm_dirty_ring_get_rsvd_entries(void)
  	return KVM_DIRTY_RING_RSVD_ENTRIES + kvm_cpu_dirty_log_size();
  }
 
Quoted 7 lines

virt/kvm/dirty_ring.c u32 kvm_dirty_ring_get_rsvd_entries(void) · line 25

Quoted 2 lines
virt/kvm/dirty_ring.c +2 -0
+bool kvm_use_dirty_bitmap(struct kvm *kvm)
+{
	lockdep_assert_held(&kvm->slots_lock);

To guard against accessing kvm->dirty_ring_with_bitmap without holding slots_lock.

Right, it makes sense to do so :)

Quoted 24 lines
Quoted 8 lines
virt/kvm/dirty_ring.c +4 -0
+	return !kvm->dirty_ring_size || kvm->dirty_ring_with_bitmap;
+}
+
@@ -4588,6 +4594,31 @@ static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
  			return -EINVAL;
 
  		return kvm_vm_ioctl_enable_dirty_log_ring(kvm, cap->args[0]);
+	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP: {

virt/kvm/dirty_ring.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4607

Quoted 10 lines
virt/kvm/dirty_ring.c +10 -0
+		struct kvm_memslots *slots;
+		int r = -EINVAL;
+
+		if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
+		    !kvm->dirty_ring_size)
+			return r;
+
+		mutex_lock(&kvm->slots_lock);
+
+		slots = kvm_memslots(kvm);

Sadly, this needs to iterate over all possible memslots thanks to x86's SMM address space. Might be worth adding a separate helper (that's local to kvm_main.c to discourage use), e.g.

static bool kvm_are_all_memslots_empty(struct kvm *kvm)

Quoted 13 lines
{
	int i;

	lockdep_assert_held(&kvm->slots_lock);

	for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
		if (!kvm_memslots_empty(__kvm_memslots(kvm, i)))
			return false;
	}

	return true;
}

Strictly speaking, x86 doesn't reach to this point because we bail on !CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP. However, it's still nice to make the check complete. Besides, the lockdep_assert_held() is duplicate to that one inside __kvm_memslots(). I would move the whole hunk of code into kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap(). In this way, kvm_vm_ioctl_enable_cap_generic() looks clean at least.

Quoted 16 lines

virt/kvm/dirty_ring.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4612

Quoted 5 lines
virt/kvm/dirty_ring.c +5 -0
+
+		/*
+		 * Avoid a race between memslot creation and enabling the ring +
+		 * bitmap capability to guarantee that no memslots have been
+		 * created without a bitmap.

Nit, it's not just enabling, the below also allows disabling the bitmap. The enabling case is definitely the most interesting, but the above wording makes it sound like the enabling case is the only thing that being given protection. That's kinda true since KVM frees bitmaps without checking kvm_use_dirty_bitmap(), but that's not a strict requirement.

And there's no race required, e.g. without this check userspace could simply create a memslot and then toggle on the capability. Acquiring slots_lock above is what guards against races.

Quoted 9 lines

Might also be worth alluding to the alternative solution of allocating the bitmap for all memslots here, e.g. something like

/*
* For simplicity, allow toggling ring+bitmap if and only if
* there are no memslots, e.g. to ensure all memslots allocate a
* bitmap after the capability is enabled.
*/

Frankly, I don't expect the capability to be disabled. Similar to KVM_CAP_DIRTY_LOG_RING or KVM_CAP_DIRTY_LOG_RING_ACQ_REL, it would a one-shot capability and only enablement is allowed. The disablement was suggested by Oliver without providing a clarify, even I dropped it for several times. I would like to see if there is particular reason why Oliver want to disable the capability.

    kvm->dirty_ring_with_bitmap = cap->args[0];

If Oliver agrees that the capability needn't to be disabled. The whole chunk of code can be squeezed into kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap() to make kvm_vm_ioctl_enable_cap_generic() a bit clean, as I said above.

Sean and Oliver, could you help to confirm if the changes look good to you? :)

    static int kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap(struct kvm *kvm)
    {
        int i, r = 0;

        if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
            !kvm->dirty_ring_size)
            return -EINVAL;

        mutex_lock(&kvm->slots_lock);

        /* We only allow it to set once */
        if (kvm->dirty_ring_with_bitmap) {
            r = -EINVAL;
            goto out_unlock;
        }

        /*
         * Avoid a race between memslot creation and enabling the ring +
         * bitmap capability to guarantee that no memslots have been
         * created without a bitmap.
         */
        for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
            if (!kvm_memslots_empty(__kvm_memslots(kvm, i))) {
                r = -EINVAL;
                goto out_unlock;
            }
        }

        kvm->dirty_ring_with_bitmap = true;

    out_unlock:
        mutex_unlock(&kvm->slots_lock);

        return r;
    }

    static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
                                               struct kvm_enable_cap *cap)
    {
        switch (cap->cap) {
          :
        case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP:
            return kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap(kvm);
        default:
            return kvm_vm_ioctl_enable_cap(kvm, cap);
        }
    }
Quoted 5 lines
Quoted 5 lines
virt/kvm/dirty_ring.c +5 -0
+		 */
+		if (kvm_memslots_empty(slots)) {
+			kvm->dirty_ring_with_bitmap = cap->args[0];
+			r = 0;
+		}
Quoted 9 lines

virt/kvm/dirty_ring.c static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm, · line 4624

Quoted 8 lines
virt/kvm/dirty_ring.c +4 -0
+
+		mutex_unlock(&kvm->slots_lock);
+		return r;
+	}
  	default:
  		return kvm_vm_ioctl_enable_cap(kvm, cap);
  	}

Thanks,
Gavin

#21 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Quoted 11 lines · Gavin Shan

Frankly, I don't expect the capability to be disabled. Similar to KVM_CAP_DIRTY_LOG_RING or KVM_CAP_DIRTY_LOG_RING_ACQ_REL, it would a one-shot capability and only enablement is allowed. The disablement was suggested by Oliver without providing a clarify, even I dropped it for several times. I would like to see if there is particular reason why Oliver want to disable the capability.

    kvm->dirty_ring_with_bitmap = cap->args[0];

If Oliver agrees that the capability needn't to be disabled. The whole chunk of code can be squeezed into kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap() to make kvm_vm_ioctl_enable_cap_generic() a bit clean, as I said above.

Sorry, I don't believe there is much use in disabling the cap, and really that hunk just came from lazily matching the neigbhoring caps when sketching out some suggestions. Oops!

Quoted 3 lines

Sean and Oliver, could you help to confirm if the changes look good to you? :)

static int kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap(struct kvm *kvm)

This function name is ridiculously long...

Quoted 7 lines
    {
        int i, r = 0;

        if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
            !kvm->dirty_ring_size)
            return -EINVAL;
Quoted 7 lines
        mutex_lock(&kvm->slots_lock);

        /* We only allow it to set once */
        if (kvm->dirty_ring_with_bitmap) {
            r = -EINVAL;
            goto out_unlock;
        }

I don't believe this check is strictly necessary. Something similar to this makes sense with caps that take a numeric value (like KVM_CAP_DIRTY_LOG_RING), but this one is a one-way boolean.

Quoted 5 lines

/*
* Avoid a race between memslot creation and enabling the ring +
* bitmap capability to guarantee that no memslots have been
* created without a bitmap.

You'll want to pick up Sean's suggestion on the comment which, again, I drafted this in haste :-)

Quoted 7 lines
         */
        for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
            if (!kvm_memslots_empty(__kvm_memslots(kvm, i))) {
                r = -EINVAL;
                goto out_unlock;
            }
        }

I'd much prefer you take Sean's suggestion and just create a helper to test that all memslots are empty. You avoid the insanely long function name and avoid the use of a goto statement. That is to say, leave the rest of the implementation inline in kvm_vm_ioctl_enable_cap_generic()

static bool kvm_are_all_memslots_empty(struct kvm *kvm)

{
	int i;

	lockdep_assert_held(&kvm->slots_lock);

	for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
		if (!kvm_memslots_empty(__kvm_memslots(kvm, i)))
			return false;
	}

	return true;
}

static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
struct kvm_enable_cap *cap)

{
	switch (cap->cap) {

[...]

	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP: {
		int r = -EINVAL;

		if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
		    !kvm->dirty_ring_size)
		    	return r;

		mutex_lock(&kvm->slots_lock);

		/*
		 * For simplicity, allow enabling ring+bitmap if and only if
		 * there are no memslots, e.g. to ensure all memslots allocate a
		 * bitmap after the capability is enabled.
		 */
		if (kvm_are_all_memslots_empty(kvm)) {
			kvm->dirty_ring_with_bitmap = true;
			r = 0;
		}

		mutex_unlock(&kvm->slots_lock);
		return r;
	}

Hmm?

--
Thanks,
Oliver

author
#22 lore raw

Re: [PATCH v8 3/7] KVM: Support dirty ring in conjunction with bitmap

Hi Oliver,

Quoted 9 lines · Oliver Upton
Quoted 8 lines · Gavin Shan

Frankly, I don't expect the capability to be disabled. Similar to KVM_CAP_DIRTY_LOG_RING or KVM_CAP_DIRTY_LOG_RING_ACQ_REL, it would a one-shot capability and only enablement is allowed. The disablement was suggested by Oliver without providing a clarify, even I dropped it for several times. I would like to see if there is particular reason why Oliver want to disable the capability.

     kvm->dirty_ring_with_bitmap = cap->args[0];
Quoted 8 lines
Quoted 3 lines

If Oliver agrees that the capability needn't to be disabled. The whole chunk of code can be squeezed into kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap() to make kvm_vm_ioctl_enable_cap_generic() a bit clean, as I said above.

Sorry, I don't believe there is much use in disabling the cap, and really that hunk just came from lazily matching the neigbhoring caps when sketching out some suggestions. Oops!

Ok. It doesn't really matter too much except the comments seems conflicting. Thanks for confirming it's unnecessary to disable the capability.

Quoted 6 lines
Quoted 3 lines

Sean and Oliver, could you help to confirm if the changes look good to you? :)

static int kvm_vm_ioctl_enable_dirty_log_ring_with_bitmap(struct kvm *kvm)

This function name is ridiculously long...

Yeah, It seems I tempted to make the function name as comments :)

Quoted 15 lines
Quoted 7 lines
     {
         int i, r = 0;

         if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
             !kvm->dirty_ring_size)
             return -EINVAL;
Quoted 7 lines
         mutex_lock(&kvm->slots_lock);

         /* We only allow it to set once */
         if (kvm->dirty_ring_with_bitmap) {
             r = -EINVAL;
             goto out_unlock;
         }
Quoted 4 lines

I don't believe this check is strictly necessary. Something similar to this makes sense with caps that take a numeric value (like KVM_CAP_DIRTY_LOG_RING), but this one is a one-way boolean.

Yep, it's not required strictly since it can represent two states.

Quoted 9 lines
Quoted 5 lines

/*
* Avoid a race between memslot creation and enabling the ring +
* bitmap capability to guarantee that no memslots have been
* created without a bitmap.

You'll want to pick up Sean's suggestion on the comment which, again, I drafted this in haste :-)

Ok, no worries :)

Quoted 57 lines
Quoted 7 lines
          */
         for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
             if (!kvm_memslots_empty(__kvm_memslots(kvm, i))) {
                 r = -EINVAL;
                 goto out_unlock;
             }
         }

I'd much prefer you take Sean's suggestion and just create a helper to test that all memslots are empty. You avoid the insanely long function name and avoid the use of a goto statement. That is to say, leave the rest of the implementation inline in kvm_vm_ioctl_enable_cap_generic()

static bool kvm_are_all_memslots_empty(struct kvm *kvm)

{
	int i;

	lockdep_assert_held(&kvm->slots_lock);

	for (i = 0; i < KVM_ADDRESS_SPACE_NUM; i++) {
		if (!kvm_memslots_empty(__kvm_memslots(kvm, i)))
			return false;
	}

	return true;
}

static int kvm_vm_ioctl_enable_cap_generic(struct kvm *kvm,
struct kvm_enable_cap *cap)

{
	switch (cap->cap) {

      [...]

	case KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP: {
		int r = -EINVAL;

		if (!IS_ENABLED(CONFIG_HAVE_KVM_DIRTY_RING_WITH_BITMAP) ||
		    !kvm->dirty_ring_size)
		    	return r;

		mutex_lock(&kvm->slots_lock);

		/*
		 * For simplicity, allow enabling ring+bitmap if and only if
		 * there are no memslots, e.g. to ensure all memslots allocate a
		 * bitmap after the capability is enabled.
		 */
		if (kvm_are_all_memslots_empty(kvm)) {
			kvm->dirty_ring_with_bitmap = true;
			r = 0;
		}

		mutex_unlock(&kvm->slots_lock);
		return r;
	}
Quoted 1 line

}

Ok. Lets change the chunk as Sean suggested in v9, which should be posted soon.

Thanks,
Gavin

author
#23 lore raw

PATCH v8 4/7 KVM: arm64: Enable ring-based dirty memory tracking

In reply to Gavin Shan

Enable ring-based dirty memory tracking on arm64 by selecting CONFIG_HAVE_KVM_DIRTY_{RING_ACQ_REL, RING_WITH_BITMAP} and providing the ring buffer's physical page offset (KVM_DIRTY_LOG_PAGE_OFFSET).

Besides, helper kvm_vgic_save_its_tables_in_progress() is added to indicate if vgic/its tables are being saved or not. The helper is used in ARM64's kvm_arch_allow_write_without_running_vcpu() to keep the site of saving vgic/its tables out of no-running-vcpu radar.

---
 Documentation/virt/kvm/api.rst     |  2 +-
 arch/arm64/include/uapi/asm/kvm.h  |  1 +
 arch/arm64/kvm/Kconfig             |  2 ++
 arch/arm64/kvm/arm.c               |  3 +++
 arch/arm64/kvm/mmu.c               | 15 +++++++++++++++
 arch/arm64/kvm/vgic/vgic-its.c     |  3 +++
 arch/arm64/kvm/vgic/vgic-mmio-v3.c |  7 +++++++
 include/kvm/arm_vgic.h             |  2 ++
 8 files changed, 34 insertions(+), 1 deletion(-)
Documentation/virt/kvm/api.rst +1 -1
index 2ec32bd41792..2fc68f684ad8 100644
@@ -7921,7 +7921,7 @@ regardless of what has actually been exposed through the CPUID leaf.
 8.29 KVM_CAP_DIRTY_LOG_RING/KVM_CAP_DIRTY_LOG_RING_ACQ_REL
 ----------------------------------------------------------
 
-:Architectures: x86
+:Architectures: x86, arm64
 :Parameters: args[0] - size of the dirty log ring
 
 KVM is capable of tracking dirty memory using ring buffers that are
arch/arm64/include/uapi/asm/kvm.h +1 -0
index 316917b98707..a7a857f1784d 100644
@@ -43,6 +43,7 @@
 #define __KVM_HAVE_VCPU_EVENTS
 
 #define KVM_COALESCED_MMIO_PAGE_OFFSET 1
+#define KVM_DIRTY_LOG_PAGE_OFFSET 64
 
 #define KVM_REG_SIZE(id)						\
 	(1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT))
arch/arm64/kvm/Kconfig +2 -0
index 815cc118c675..066b053e9eb9 100644
@@ -32,6 +32,8 @@ menuconfig KVM
 	select KVM_VFIO
 	select HAVE_KVM_EVENTFD
 	select HAVE_KVM_IRQFD
+	select HAVE_KVM_DIRTY_RING_ACQ_REL
+	select HAVE_KVM_DIRTY_RING_WITH_BITMAP
 	select HAVE_KVM_MSI
 	select HAVE_KVM_IRQCHIP
 	select HAVE_KVM_IRQ_ROUTING
arch/arm64/kvm/arm.c +3 -0
index 94d33e296e10..6b097605e38c 100644
@@ -746,6 +746,9 @@ static int check_vcpu_requests(struct kvm_vcpu *vcpu)
 
 		if (kvm_check_request(KVM_REQ_SUSPEND, vcpu))
 			return kvm_vcpu_suspend(vcpu);
+
+		if (kvm_dirty_ring_check_request(vcpu))
+			return 0;
 	}
 
 	return 1;
arch/arm64/kvm/mmu.c +15 -0
index 60ee3d9f01f8..fbeb55e45f53 100644
@@ -932,6 +932,21 @@ void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
 	kvm_mmu_write_protect_pt_masked(kvm, slot, gfn_offset, mask);
 }
 
+/*
+ * kvm_arch_allow_write_without_running_vcpu - allow writing guest memory
+ * without the running VCPU when dirty ring is enabled.
+ *
+ * The running VCPU is required to track dirty guest pages when dirty ring
+ * is enabled. Otherwise, the backup bitmap should be used to track the
+ * dirty guest pages. When vgic/its tables are being saved, the backup
+ * bitmap is used to track the dirty guest pages due to the missed running
+ * VCPU in the period.
+ */
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return kvm_vgic_save_its_tables_in_progress(kvm);
+}
+
 static void kvm_send_hwpoison_signal(unsigned long address, short lsb)
 {
 	send_sig_mceerr(BUS_MCEERR_AR, (void __user *)address, lsb, current);
arch/arm64/kvm/vgic/vgic-its.c +3 -0
index 733b53055f97..dd340bb812bd 100644
@@ -2743,6 +2743,7 @@ static int vgic_its_has_attr(struct kvm_device *dev,
 static int vgic_its_ctrl(struct kvm *kvm, struct vgic_its *its, u64 attr)
 {
 	const struct vgic_its_abi *abi = vgic_its_get_abi(its);
+	struct vgic_dist *dist = &kvm->arch.vgic;
 	int ret = 0;
 
 	if (attr == KVM_DEV_ARM_VGIC_CTRL_INIT) /* Nothing to do */
@@ -2762,7 +2763,9 @@ static int vgic_its_ctrl(struct kvm *kvm, struct vgic_its *its, u64 attr)
 		vgic_its_reset(kvm, its);
 		break;
 	case KVM_DEV_ARM_ITS_SAVE_TABLES:
+		dist->save_its_tables_in_progress = true;
 		ret = abi->save_tables(its);
+		dist->save_its_tables_in_progress = false;
 		break;
 	case KVM_DEV_ARM_ITS_RESTORE_TABLES:
 		ret = abi->restore_tables(its);
arch/arm64/kvm/vgic/vgic-mmio-v3.c +7 -0
index 91201f743033..b63898f86e9e 100644
@@ -54,6 +54,13 @@ bool vgic_supports_direct_msis(struct kvm *kvm)
 		(kvm_vgic_global_state.has_gicv4 && vgic_has_its(kvm)));
 }
 
+bool kvm_vgic_save_its_tables_in_progress(struct kvm *kvm)
+{
+	struct vgic_dist *dist = &kvm->arch.vgic;
+
+	return dist->save_its_tables_in_progress;
+}
+
 /*
  * The Revision field in the IIDR have the following meanings:
  *
include/kvm/arm_vgic.h +2 -0
index 4df9e73a8bb5..db42fbd47bcf 100644
@@ -263,6 +263,7 @@ struct vgic_dist {
 	struct vgic_io_device	dist_iodev;
 
 	bool			has_its;
+	bool			save_its_tables_in_progress;
 
 	/*
 	 * Contains the attributes and gpa of the LPI configuration table.
@@ -374,6 +375,7 @@ int kvm_vgic_map_resources(struct kvm *kvm);
 int kvm_vgic_hyp_init(void);
 void kvm_vgic_init_cpu_hardware(void);
 
+bool kvm_vgic_save_its_tables_in_progress(struct kvm *kvm);
 int kvm_vgic_inject_irq(struct kvm *kvm, int cpuid, unsigned int intid,
 			bool level, void *owner);
 int kvm_vgic_map_phys_irq(struct kvm_vcpu *vcpu, unsigned int host_irq,
Signature · 6 lines
2.23.0

_______________________________________________
kvmarm mailing list
[email protected]
https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
maintainer
#24 lore raw
Quoted 85 lines · Gavin Shan

Enable ring-based dirty memory tracking on arm64 by selecting CONFIG_HAVE_KVM_DIRTY_{RING_ACQ_REL, RING_WITH_BITMAP} and providing the ring buffer's physical page offset (KVM_DIRTY_LOG_PAGE_OFFSET).

Besides, helper kvm_vgic_save_its_tables_in_progress() is added to indicate if vgic/its tables are being saved or not. The helper is used in ARM64's kvm_arch_allow_write_without_running_vcpu() to keep the site of saving vgic/its tables out of no-running-vcpu radar.

---
 Documentation/virt/kvm/api.rst     |  2 +-
 arch/arm64/include/uapi/asm/kvm.h  |  1 +
 arch/arm64/kvm/Kconfig             |  2 ++
 arch/arm64/kvm/arm.c               |  3 +++
 arch/arm64/kvm/mmu.c               | 15 +++++++++++++++
 arch/arm64/kvm/vgic/vgic-its.c     |  3 +++
 arch/arm64/kvm/vgic/vgic-mmio-v3.c |  7 +++++++
 include/kvm/arm_vgic.h             |  2 ++
 8 files changed, 34 insertions(+), 1 deletion(-)
Documentation/virt/kvm/api.rst +1 -1
index 2ec32bd41792..2fc68f684ad8 100644
@@ -7921,7 +7921,7 @@ regardless of what has actually been exposed through the CPUID leaf.
 8.29 KVM_CAP_DIRTY_LOG_RING/KVM_CAP_DIRTY_LOG_RING_ACQ_REL
 ----------------------------------------------------------
 
-:Architectures: x86
+:Architectures: x86, arm64
 :Parameters: args[0] - size of the dirty log ring
 
 KVM is capable of tracking dirty memory using ring buffers that are
arch/arm64/include/uapi/asm/kvm.h +1 -0
index 316917b98707..a7a857f1784d 100644
@@ -43,6 +43,7 @@
 #define __KVM_HAVE_VCPU_EVENTS
 
 #define KVM_COALESCED_MMIO_PAGE_OFFSET 1
+#define KVM_DIRTY_LOG_PAGE_OFFSET 64
 
 #define KVM_REG_SIZE(id)						\
 	(1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT))
arch/arm64/kvm/Kconfig +2 -0
index 815cc118c675..066b053e9eb9 100644
@@ -32,6 +32,8 @@ menuconfig KVM
 	select KVM_VFIO
 	select HAVE_KVM_EVENTFD
 	select HAVE_KVM_IRQFD
+	select HAVE_KVM_DIRTY_RING_ACQ_REL
+	select HAVE_KVM_DIRTY_RING_WITH_BITMAP
 	select HAVE_KVM_MSI
 	select HAVE_KVM_IRQCHIP
 	select HAVE_KVM_IRQ_ROUTING
arch/arm64/kvm/arm.c +3 -0
index 94d33e296e10..6b097605e38c 100644
@@ -746,6 +746,9 @@ static int check_vcpu_requests(struct kvm_vcpu *vcpu)
 
 		if (kvm_check_request(KVM_REQ_SUSPEND, vcpu))
 			return kvm_vcpu_suspend(vcpu);
+
+		if (kvm_dirty_ring_check_request(vcpu))
+			return 0;
 	}
 
 	return 1;
arch/arm64/kvm/mmu.c +3 -0
index 60ee3d9f01f8..fbeb55e45f53 100644
@@ -932,6 +932,21 @@ void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
 	kvm_mmu_write_protect_pt_masked(kvm, slot, gfn_offset, mask);
 }
 
+/*
+ * kvm_arch_allow_write_without_running_vcpu - allow writing guest memory
+ * without the running VCPU when dirty ring is enabled.

arch/arm64/kvm/mmu.c void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm, · line 947

Quoted 10 lines
arch/arm64/kvm/mmu.c +10 -0
+ *
+ * The running VCPU is required to track dirty guest pages when dirty ring
+ * is enabled. Otherwise, the backup bitmap should be used to track the
+ * dirty guest pages. When vgic/its tables are being saved, the backup
+ * bitmap is used to track the dirty guest pages due to the missed running
+ * VCPU in the period.
+ */
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return kvm_vgic_save_its_tables_in_progress(kvm);

I don't think we need the extra level of abstraction here. Just return kvm->arch.vgic.save_its_tables_in_progress and be done with it.

You can also move the helper to the vgic-its code since they are closely related for now.

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author
#25 lore raw

Hi Marc,

Quoted 101 lines · Marc Zyngier
Quoted 85 lines · Gavin Shan

Enable ring-based dirty memory tracking on arm64 by selecting CONFIG_HAVE_KVM_DIRTY_{RING_ACQ_REL, RING_WITH_BITMAP} and providing the ring buffer's physical page offset (KVM_DIRTY_LOG_PAGE_OFFSET).

Besides, helper kvm_vgic_save_its_tables_in_progress() is added to indicate if vgic/its tables are being saved or not. The helper is used in ARM64's kvm_arch_allow_write_without_running_vcpu() to keep the site of saving vgic/its tables out of no-running-vcpu radar.

---
  Documentation/virt/kvm/api.rst     |  2 +-
  arch/arm64/include/uapi/asm/kvm.h  |  1 +
  arch/arm64/kvm/Kconfig             |  2 ++
  arch/arm64/kvm/arm.c               |  3 +++
  arch/arm64/kvm/mmu.c               | 15 +++++++++++++++
  arch/arm64/kvm/vgic/vgic-its.c     |  3 +++
  arch/arm64/kvm/vgic/vgic-mmio-v3.c |  7 +++++++
  include/kvm/arm_vgic.h             |  2 ++
  8 files changed, 34 insertions(+), 1 deletion(-)
Documentation/virt/kvm/api.rst +1 -1
index 2ec32bd41792..2fc68f684ad8 100644
@@ -7921,7 +7921,7 @@ regardless of what has actually been exposed through the CPUID leaf.
  8.29 KVM_CAP_DIRTY_LOG_RING/KVM_CAP_DIRTY_LOG_RING_ACQ_REL
  ----------------------------------------------------------
 
-:Architectures: x86
+:Architectures: x86, arm64
  :Parameters: args[0] - size of the dirty log ring
 
  KVM is capable of tracking dirty memory using ring buffers that are
arch/arm64/include/uapi/asm/kvm.h +1 -0
index 316917b98707..a7a857f1784d 100644
@@ -43,6 +43,7 @@
  #define __KVM_HAVE_VCPU_EVENTS
 
  #define KVM_COALESCED_MMIO_PAGE_OFFSET 1
+#define KVM_DIRTY_LOG_PAGE_OFFSET 64
 
  #define KVM_REG_SIZE(id)						\
  	(1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT))
arch/arm64/kvm/Kconfig +2 -0
index 815cc118c675..066b053e9eb9 100644
@@ -32,6 +32,8 @@ menuconfig KVM
  	select KVM_VFIO
  	select HAVE_KVM_EVENTFD
  	select HAVE_KVM_IRQFD
+	select HAVE_KVM_DIRTY_RING_ACQ_REL
+	select HAVE_KVM_DIRTY_RING_WITH_BITMAP
  	select HAVE_KVM_MSI
  	select HAVE_KVM_IRQCHIP
  	select HAVE_KVM_IRQ_ROUTING
arch/arm64/kvm/arm.c +3 -0
index 94d33e296e10..6b097605e38c 100644
@@ -746,6 +746,9 @@ static int check_vcpu_requests(struct kvm_vcpu *vcpu)
 
  		if (kvm_check_request(KVM_REQ_SUSPEND, vcpu))
  			return kvm_vcpu_suspend(vcpu);
+
+		if (kvm_dirty_ring_check_request(vcpu))
+			return 0;
  	}
 
  	return 1;
arch/arm64/kvm/mmu.c +3 -0
index 60ee3d9f01f8..fbeb55e45f53 100644
@@ -932,6 +932,21 @@ void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
  	kvm_mmu_write_protect_pt_masked(kvm, slot, gfn_offset, mask);
  }
 
+/*
+ * kvm_arch_allow_write_without_running_vcpu - allow writing guest memory
+ * without the running VCPU when dirty ring is enabled.

arch/arm64/kvm/mmu.c void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm, · line 947

Quoted 10 lines
arch/arm64/kvm/mmu.c +10 -0
+ *
+ * The running VCPU is required to track dirty guest pages when dirty ring
+ * is enabled. Otherwise, the backup bitmap should be used to track the
+ * dirty guest pages. When vgic/its tables are being saved, the backup
+ * bitmap is used to track the dirty guest pages due to the missed running
+ * VCPU in the period.
+ */
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return kvm_vgic_save_its_tables_in_progress(kvm);

I don't think we need the extra level of abstraction here. Just return kvm->arch.vgic.save_its_tables_in_progress and be done with it.

Quoted 3 lines

You can also move the helper to the vgic-its code since they are closely related for now.

Ok. After kvm_arch_allow_write_without_running_vcpu() is moved to vgic-its.c, do we need to replace 'struct vgic_dist::save_its_tables_in_progress' with a file-scoped variant ('bool vgic_its_saving_tables') ?

Thanks,
Gavin

maintainer
#26 lore raw
Quoted 100 lines · Gavin Shan

Hi Marc,

Quoted 96 lines · Marc Zyngier
Quoted 80 lines · Gavin Shan

Enable ring-based dirty memory tracking on arm64 by selecting CONFIG_HAVE_KVM_DIRTY_{RING_ACQ_REL, RING_WITH_BITMAP} and providing the ring buffer's physical page offset (KVM_DIRTY_LOG_PAGE_OFFSET).

Besides, helper kvm_vgic_save_its_tables_in_progress() is added to indicate if vgic/its tables are being saved or not. The helper is used in ARM64's kvm_arch_allow_write_without_running_vcpu() to keep the site of saving vgic/its tables out of no-running-vcpu radar.

---
  Documentation/virt/kvm/api.rst     |  2 +-
  arch/arm64/include/uapi/asm/kvm.h  |  1 +
  arch/arm64/kvm/Kconfig             |  2 ++
  arch/arm64/kvm/arm.c               |  3 +++
  arch/arm64/kvm/mmu.c               | 15 +++++++++++++++
  arch/arm64/kvm/vgic/vgic-its.c     |  3 +++
  arch/arm64/kvm/vgic/vgic-mmio-v3.c |  7 +++++++
  include/kvm/arm_vgic.h             |  2 ++
  8 files changed, 34 insertions(+), 1 deletion(-)
Documentation/virt/kvm/api.rst +1 -0
index 2ec32bd41792..2fc68f684ad8 100644
@@ -7921,7 +7921,7 @@ regardless of what has actually been exposed through the CPUID leaf.
  8.29 KVM_CAP_DIRTY_LOG_RING/KVM_CAP_DIRTY_LOG_RING_ACQ_REL
  ----------------------------------------------------------
  -:Architectures: x86
+:Architectures: x86, arm64
  :Parameters: args[0] - size of the dirty log ring
    KVM is capable of tracking dirty memory using ring buffers that

are

arch/arm64/include/uapi/asm/kvm.h +1 -0
index 316917b98707..a7a857f1784d 100644
@@ -43,6 +43,7 @@
  #define __KVM_HAVE_VCPU_EVENTS
    #define KVM_COALESCED_MMIO_PAGE_OFFSET 1
+#define KVM_DIRTY_LOG_PAGE_OFFSET 64
    #define KVM_REG_SIZE(id)
 \
  	(1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT))
arch/arm64/kvm/Kconfig +2 -0
index 815cc118c675..066b053e9eb9 100644
@@ -32,6 +32,8 @@ menuconfig KVM
  	select KVM_VFIO
  	select HAVE_KVM_EVENTFD
  	select HAVE_KVM_IRQFD
+	select HAVE_KVM_DIRTY_RING_ACQ_REL
+	select HAVE_KVM_DIRTY_RING_WITH_BITMAP
  	select HAVE_KVM_MSI
  	select HAVE_KVM_IRQCHIP
  	select HAVE_KVM_IRQ_ROUTING
arch/arm64/kvm/arm.c +3 -0
index 94d33e296e10..6b097605e38c 100644
@@ -746,6 +746,9 @@ static int check_vcpu_requests(struct kvm_vcpu *vcpu)
    		if (kvm_check_request(KVM_REQ_SUSPEND, vcpu))
  			return kvm_vcpu_suspend(vcpu);
+
+		if (kvm_dirty_ring_check_request(vcpu))
+			return 0;
  	}
    	return 1;
arch/arm64/kvm/mmu.c +2 -0
index 60ee3d9f01f8..fbeb55e45f53 100644
@@ -932,6 +932,21 @@ void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
  	kvm_mmu_write_protect_pt_masked(kvm, slot, gfn_offset, mask);
  }
  +/*
+ * kvm_arch_allow_write_without_running_vcpu - allow writing guest memory
+ * without the running VCPU when dirty ring is enabled.

arch/arm64/kvm/mmu.c void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm, · line 946

Quoted 10 lines
arch/arm64/kvm/mmu.c +10 -0
+ *
+ * The running VCPU is required to track dirty guest pages when dirty ring
+ * is enabled. Otherwise, the backup bitmap should be used to track the
+ * dirty guest pages. When vgic/its tables are being saved, the backup
+ * bitmap is used to track the dirty guest pages due to the missed running
+ * VCPU in the period.
+ */
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return kvm_vgic_save_its_tables_in_progress(kvm);

I don't think we need the extra level of abstraction here. Just return kvm->arch.vgic.save_its_tables_in_progress and be done with it.

Quoted 7 lines
Quoted 3 lines

You can also move the helper to the vgic-its code since they are closely related for now.

Ok. After kvm_arch_allow_write_without_running_vcpu() is moved to vgic-its.c, do we need to replace 'struct vgic_dist::save_its_tables_in_progress' with a file-scoped variant ('bool vgic_its_saving_tables') ?

No, this still needs to be per-VM.

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author
#27 lore raw

Hi Marc,

Quoted 103 lines · Marc Zyngier
Quoted 101 lines · Gavin Shan
Quoted 99 lines · Marc Zyngier
Quoted 80 lines · Gavin Shan

Enable ring-based dirty memory tracking on arm64 by selecting CONFIG_HAVE_KVM_DIRTY_{RING_ACQ_REL, RING_WITH_BITMAP} and providing the ring buffer's physical page offset (KVM_DIRTY_LOG_PAGE_OFFSET).

Besides, helper kvm_vgic_save_its_tables_in_progress() is added to indicate if vgic/its tables are being saved or not. The helper is used in ARM64's kvm_arch_allow_write_without_running_vcpu() to keep the site of saving vgic/its tables out of no-running-vcpu radar.

---
   Documentation/virt/kvm/api.rst     |  2 +-
   arch/arm64/include/uapi/asm/kvm.h  |  1 +
   arch/arm64/kvm/Kconfig             |  2 ++
   arch/arm64/kvm/arm.c               |  3 +++
   arch/arm64/kvm/mmu.c               | 15 +++++++++++++++
   arch/arm64/kvm/vgic/vgic-its.c     |  3 +++
   arch/arm64/kvm/vgic/vgic-mmio-v3.c |  7 +++++++
   include/kvm/arm_vgic.h             |  2 ++
   8 files changed, 34 insertions(+), 1 deletion(-)
Documentation/virt/kvm/api.rst +1 -0
index 2ec32bd41792..2fc68f684ad8 100644
@@ -7921,7 +7921,7 @@ regardless of what has actually been exposed through the CPUID leaf.
   8.29 KVM_CAP_DIRTY_LOG_RING/KVM_CAP_DIRTY_LOG_RING_ACQ_REL
   ----------------------------------------------------------
   -:Architectures: x86
+:Architectures: x86, arm64
   :Parameters: args[0] - size of the dirty log ring
     KVM is capable of tracking dirty memory using ring buffers that

are

arch/arm64/include/uapi/asm/kvm.h +1 -0
index 316917b98707..a7a857f1784d 100644
@@ -43,6 +43,7 @@
   #define __KVM_HAVE_VCPU_EVENTS
     #define KVM_COALESCED_MMIO_PAGE_OFFSET 1
+#define KVM_DIRTY_LOG_PAGE_OFFSET 64
     #define KVM_REG_SIZE(id)
 \
   	(1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT))
arch/arm64/kvm/Kconfig +2 -0
index 815cc118c675..066b053e9eb9 100644
@@ -32,6 +32,8 @@ menuconfig KVM
   	select KVM_VFIO
   	select HAVE_KVM_EVENTFD
   	select HAVE_KVM_IRQFD
+	select HAVE_KVM_DIRTY_RING_ACQ_REL
+	select HAVE_KVM_DIRTY_RING_WITH_BITMAP
   	select HAVE_KVM_MSI
   	select HAVE_KVM_IRQCHIP
   	select HAVE_KVM_IRQ_ROUTING
arch/arm64/kvm/arm.c +3 -0
index 94d33e296e10..6b097605e38c 100644
@@ -746,6 +746,9 @@ static int check_vcpu_requests(struct kvm_vcpu *vcpu)
     		if (kvm_check_request(KVM_REQ_SUSPEND, vcpu))
   			return kvm_vcpu_suspend(vcpu);
+
+		if (kvm_dirty_ring_check_request(vcpu))
+			return 0;
   	}
     	return 1;
arch/arm64/kvm/mmu.c +2 -0
index 60ee3d9f01f8..fbeb55e45f53 100644
@@ -932,6 +932,21 @@ void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
   	kvm_mmu_write_protect_pt_masked(kvm, slot, gfn_offset, mask);
   }
   +/*
+ * kvm_arch_allow_write_without_running_vcpu - allow writing guest memory
+ * without the running VCPU when dirty ring is enabled.

arch/arm64/kvm/mmu.c void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm, · line 946

Quoted 10 lines
arch/arm64/kvm/mmu.c +10 -0
+ *
+ * The running VCPU is required to track dirty guest pages when dirty ring
+ * is enabled. Otherwise, the backup bitmap should be used to track the
+ * dirty guest pages. When vgic/its tables are being saved, the backup
+ * bitmap is used to track the dirty guest pages due to the missed running
+ * VCPU in the period.
+ */
+bool kvm_arch_allow_write_without_running_vcpu(struct kvm *kvm)
+{
+	return kvm_vgic_save_its_tables_in_progress(kvm);

I don't think we need the extra level of abstraction here. Just return kvm->arch.vgic.save_its_tables_in_progress and be done with it.

You can also move the helper to the vgic-its code since they are closely related for now.

Quoted 6 lines
Quoted 3 lines

Ok. After kvm_arch_allow_write_without_running_vcpu() is moved to vgic-its.c, do we need to replace 'struct vgic_dist::save_its_tables_in_progress' with a file-scoped variant ('bool vgic_its_saving_tables') ?

No, this still needs to be per-VM.

Yeah, it's still per-VM state. Sorry for my dumb question :)

Thanks,
Gavin

author
#28 lore raw

PATCH v8 5/7 KVM: selftests: Use host page size to map ring buffer in dirty_log_test

In reply to Gavin Shan

In vcpu_map_dirty_ring(), the guest's page size is used to figure out the offset in the virtual area. It works fine when we have same page sizes on host and guest. However, it fails when the page sizes on host and guest are different on arm64, like below error messages indicates.

  # ./dirty_log_test -M dirty-ring -m 7
  Setting log mode to: 'dirty-ring'
  Test iterations: 32, interval: 10 (ms)
  Testing guest mode: PA-bits:40,  VA-bits:48, 64K pages
  guest physical test memory offset: 0xffbffc0000
  vcpu stops because vcpu is kicked out...
  Notifying vcpu to continue
  vcpu continues now.
  ==== Test Assertion Failure ====
  lib/kvm_util.c:1477: addr == MAP_FAILED
  pid=9000 tid=9000 errno=0 - Success
  1  0x0000000000405f5b: vcpu_map_dirty_ring at kvm_util.c:1477
  2  0x0000000000402ebb: dirty_ring_collect_dirty_pages at dirty_log_test.c:349
  3  0x00000000004029b3: log_mode_collect_dirty_pages at dirty_log_test.c:478
  4  (inlined by) run_test at dirty_log_test.c:778
  5  (inlined by) run_test at dirty_log_test.c:691
  6  0x0000000000403a57: for_each_guest_mode at guest_modes.c:105
  7  0x0000000000401ccf: main at dirty_log_test.c:921
  8  0x0000ffffb06ec79b: ?? ??:0
  9  0x0000ffffb06ec86b: ?? ??:0
  10 0x0000000000401def: _start at ??:?
  Dirty ring mapped private

Fix the issue by using host's page size to map the ring buffer.

---
 tools/testing/selftests/kvm/lib/kvm_util.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tools/testing/selftests/kvm/lib/kvm_util.c +1 -1
index f1cb1627161f..89a1a420ebd5 100644
@@ -1506,7 +1506,7 @@ struct kvm_reg_list *vcpu_get_reg_list(struct kvm_vcpu *vcpu)
 
 void *vcpu_map_dirty_ring(struct kvm_vcpu *vcpu)
 {
-	uint32_t page_size = vcpu->vm->page_size;
+	uint32_t page_size = getpagesize();
 	uint32_t size = vcpu->vm->dirty_ring_size;
 
 	TEST_ASSERT(size > 0, "Should enable dirty ring first");
Signature · 1 line
2.23.0
author
#29 lore raw

PATCH v8 6/7 KVM: selftests: Clear dirty ring states between two modes in dirty_log_test

In reply to Gavin Shan

There are two states, which need to be cleared before next mode is executed. Otherwise, we will hit failure as the following messages indicate.

- The variable 'dirty_ring_vcpu_ring_full' shared by main and vcpu thread. It's indicating if the vcpu exit due to full ring buffer. The value can be carried from previous mode (VM_MODE_P40V48_4K) to current one (VM_MODE_P40V48_64K) when VM_MODE_P40V48_16K isn't supported.

- The current ring buffer index needs to be reset before next mode (VM_MODE_P40V48_64K) is executed. Otherwise, the stale value is carried from previous mode (VM_MODE_P40V48_4K).

  # ./dirty_log_test -M dirty-ring
  Setting log mode to: 'dirty-ring'
  Test iterations: 32, interval: 10 (ms)
  Testing guest mode: PA-bits:40,  VA-bits:48,  4K pages
  guest physical test memory offset: 0xffbfffc000
    :
  Dirtied 995328 pages
  Total bits checked: dirty (1012434), clear (7114123), track_next (966700)
  Testing guest mode: PA-bits:40,  VA-bits:48, 64K pages
  guest physical test memory offset: 0xffbffc0000
  vcpu stops because vcpu is kicked out...
  vcpu continues now.
  Notifying vcpu to continue
  Iteration 1 collected 0 pages
  vcpu stops because dirty ring is full...
  vcpu continues now.
  vcpu stops because dirty ring is full...
  vcpu continues now.
  vcpu stops because dirty ring is full...
  ==== Test Assertion Failure ====
  dirty_log_test.c:369: cleared == count
  pid=10541 tid=10541 errno=22 - Invalid argument
     1	0x0000000000403087: dirty_ring_collect_dirty_pages at dirty_log_test.c:369
     2	0x0000000000402a0b: log_mode_collect_dirty_pages at dirty_log_test.c:492
     3	 (inlined by) run_test at dirty_log_test.c:795
     4	 (inlined by) run_test at dirty_log_test.c:705
     5	0x0000000000403a37: for_each_guest_mode at guest_modes.c:100
     6	0x0000000000401ccf: main at dirty_log_test.c:938
     7	0x0000ffff9ecd279b: ?? ??:0
     8	0x0000ffff9ecd286b: ?? ??:0
     9	0x0000000000401def: _start at ??:?
  Reset dirty pages (0) mismatch with collected (35566)

Fix the issues by clearing 'dirty_ring_vcpu_ring_full' and the ring buffer index before next new mode is to be executed.

---
 tools/testing/selftests/kvm/dirty_log_test.c | 27 ++++++++++++--------
 1 file changed, 17 insertions(+), 10 deletions(-)
tools/testing/selftests/kvm/dirty_log_test.c +17 -10
index b5234d6efbe1..8758c10ec850 100644
@@ -226,13 +226,15 @@ static void clear_log_create_vm_done(struct kvm_vm *vm)
 }
 
 static void dirty_log_collect_dirty_pages(struct kvm_vcpu *vcpu, int slot,
-					  void *bitmap, uint32_t num_pages)
+					  void *bitmap, uint32_t num_pages,
+					  uint32_t *unused)
 {
 	kvm_vm_get_dirty_log(vcpu->vm, slot, bitmap);
 }
 
 static void clear_log_collect_dirty_pages(struct kvm_vcpu *vcpu, int slot,
-					  void *bitmap, uint32_t num_pages)
+					  void *bitmap, uint32_t num_pages,
+					  uint32_t *unused)
 {
 	kvm_vm_get_dirty_log(vcpu->vm, slot, bitmap);
 	kvm_vm_clear_dirty_log(vcpu->vm, slot, bitmap, 0, num_pages);
@@ -329,10 +331,9 @@ static void dirty_ring_continue_vcpu(void)
 }
 
 static void dirty_ring_collect_dirty_pages(struct kvm_vcpu *vcpu, int slot,
-					   void *bitmap, uint32_t num_pages)
+					   void *bitmap, uint32_t num_pages,
+					   uint32_t *ring_buf_idx)
 {
-	/* We only have one vcpu */
-	static uint32_t fetch_index = 0;
 	uint32_t count = 0, cleared;
 	bool continued_vcpu = false;
 
@@ -349,7 +350,8 @@ static void dirty_ring_collect_dirty_pages(struct kvm_vcpu *vcpu, int slot,
 
 	/* Only have one vcpu */
 	count = dirty_ring_collect_one(vcpu_map_dirty_ring(vcpu),
-				       slot, bitmap, num_pages, &fetch_index);
+				       slot, bitmap, num_pages,
+				       ring_buf_idx);
 
 	cleared = kvm_vm_reset_dirty_ring(vcpu->vm);
 
@@ -406,7 +408,8 @@ struct log_mode {
 	void (*create_vm_done)(struct kvm_vm *vm);
 	/* Hook to collect the dirty pages into the bitmap provided */
 	void (*collect_dirty_pages) (struct kvm_vcpu *vcpu, int slot,
-				     void *bitmap, uint32_t num_pages);
+				     void *bitmap, uint32_t num_pages,
+				     uint32_t *ring_buf_idx);
 	/* Hook to call when after each vcpu run */
 	void (*after_vcpu_run)(struct kvm_vcpu *vcpu, int ret, int err);
 	void (*before_vcpu_join) (void);
@@ -471,13 +474,14 @@ static void log_mode_create_vm_done(struct kvm_vm *vm)
 }
 
 static void log_mode_collect_dirty_pages(struct kvm_vcpu *vcpu, int slot,
-					 void *bitmap, uint32_t num_pages)
+					 void *bitmap, uint32_t num_pages,
+					 uint32_t *ring_buf_idx)
 {
 	struct log_mode *mode = &log_modes[host_log_mode];
 
 	TEST_ASSERT(mode->collect_dirty_pages != NULL,
 		    "collect_dirty_pages() is required for any log mode!");
-	mode->collect_dirty_pages(vcpu, slot, bitmap, num_pages);
+	mode->collect_dirty_pages(vcpu, slot, bitmap, num_pages, ring_buf_idx);
 }
 
 static void log_mode_after_vcpu_run(struct kvm_vcpu *vcpu, int ret, int err)
@@ -696,6 +700,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)
 	struct kvm_vcpu *vcpu;
 	struct kvm_vm *vm;
 	unsigned long *bmap;
+	uint32_t ring_buf_idx = 0;
 
 	if (!log_mode_supported()) {
 		print_skip("Log mode '%s' not supported",
@@ -771,6 +776,7 @@ static void run_test(enum vm_guest_mode mode, void *arg)
 	host_dirty_count = 0;
 	host_clear_count = 0;
 	host_track_next_count = 0;
+	WRITE_ONCE(dirty_ring_vcpu_ring_full, false);
 
 	pthread_create(&vcpu_thread, NULL, vcpu_worker, vcpu);
 
@@ -778,7 +784,8 @@ static void run_test(enum vm_guest_mode mode, void *arg)
 		/* Give the vcpu thread some time to dirty some pages */
 		usleep(p->interval * 1000);
 		log_mode_collect_dirty_pages(vcpu, TEST_MEM_SLOT_INDEX,
-					     bmap, host_num_pages);
+					     bmap, host_num_pages,
+					     &ring_buf_idx);
 
 		/*
 		 * See vcpu_sync_stop_requested definition for details on why
Signature · 1 line
2.23.0
author
#30 lore raw

PATCH v8 7/7 KVM: selftests: Automate choosing dirty ring size in dirty_log_test

In reply to Gavin Shan

In the dirty ring case, we rely on vcpu exit due to full dirty ring state. On ARM64 system, there are 4096 host pages when the host page size is 64KB. In this case, the vcpu never exits due to the full dirty ring state. The similar case is 4KB page size on host and 64KB page size on guest. The vcpu corrupts same set of host pages, but the dirty page information isn't collected in the main thread. This leads to infinite loop as the following log shows.

  # ./dirty_log_test -M dirty-ring -c 65536 -m 5
  Setting log mode to: 'dirty-ring'
  Test iterations: 32, interval: 10 (ms)
  Testing guest mode: PA-bits:40,  VA-bits:48,  4K pages
  guest physical test memory offset: 0xffbffe0000
  vcpu stops because vcpu is kicked out...
  Notifying vcpu to continue
  vcpu continues now.
  Iteration 1 collected 576 pages
  <No more output afterwards>

Fix the issue by automatically choosing the best dirty ring size, to ensure vcpu exit due to full dirty ring state. The option '-c' becomes a hint to the dirty ring count, instead of the value of it.

---
 tools/testing/selftests/kvm/dirty_log_test.c | 26 +++++++++++++++++---
 1 file changed, 22 insertions(+), 4 deletions(-)
tools/testing/selftests/kvm/dirty_log_test.c +22 -4
index 8758c10ec850..a87e5f78ebf1 100644
@@ -24,6 +24,9 @@
 #include "guest_modes.h"
 #include "processor.h"
 
+#define DIRTY_MEM_BITS 30 /* 1G */
+#define PAGE_SHIFT_4K  12
+
 /* The memory slot index to track dirty pages */
 #define TEST_MEM_SLOT_INDEX		1
 
@@ -273,6 +276,24 @@ static bool dirty_ring_supported(void)
 
 static void dirty_ring_create_vm_done(struct kvm_vm *vm)
 {
+	uint64_t pages;
+	uint32_t limit;
+
+	/*
+	 * We rely on vcpu exit due to full dirty ring state. Adjust
+	 * the ring buffer size to ensure we're able to reach the
+	 * full dirty ring state.
+	 */
+	pages = (1ul << (DIRTY_MEM_BITS - vm->page_shift)) + 3;
+	pages = vm_adjust_num_guest_pages(vm->mode, pages);
+	if (vm->page_size < getpagesize())
+		pages = vm_num_host_pages(vm->mode, pages);
+
+	limit = 1 << (31 - __builtin_clz(pages));
+	test_dirty_ring_count = 1 << (31 - __builtin_clz(test_dirty_ring_count));
+	test_dirty_ring_count = min(limit, test_dirty_ring_count);
+	pr_info("dirty ring count: 0x%x\n", test_dirty_ring_count);
+
 	/*
 	 * Switch to dirty ring mode after VM creation but before any
 	 * of the vcpu creation.
@@ -685,9 +706,6 @@ static struct kvm_vm *create_vm(enum vm_guest_mode mode, struct kvm_vcpu **vcpu,
 	return vm;
 }
 
-#define DIRTY_MEM_BITS 30 /* 1G */
-#define PAGE_SHIFT_4K  12
-
 struct test_params {
 	unsigned long iterations;
 	unsigned long interval;
@@ -830,7 +848,7 @@ static void help(char *name)
 	printf("usage: %s [-h] [-i iterations] [-I interval] "
 	       "[-p offset] [-m mode]\n", name);
 	puts("");
-	printf(" -c: specify dirty ring size, in number of entries\n");
+	printf(" -c: hint to dirty ring size, in number of entries\n");
 	printf("     (only useful for dirty-ring test; default: %"PRIu32")\n",
 	       TEST_DIRTY_RING_COUNT);
 	printf(" -i: specify iteration counts (default: %"PRIu64")\n",
Signature · 1 line
2.23.0
maintainer
#31 lore raw
In reply to Gavin Shan
Quoted 10 lines · Gavin Shan

This series enables the ring-based dirty memory tracking for ARM64. The feature has been available and enabled on x86 for a while. It is beneficial when the number of dirty pages is small in a checkpointing system or live migration scenario. More details can be found from fb04a1eddb1a ("KVM: X86: Implement ring-based dirty memory tracking").

This series is applied to v6.1.rc3, plus commit c227590467cb ("KVM:
Check KVM_CAP_DIRTY_LOG_{RING, RING_ACQ_REL} prior to enabling them"). The commit is currently in Marc's 'fixes' branch, targeting v6.1.rc4/5.

This is starting to look good to me, and my only concerns are around the documentation and the bit of nitpicking on patch 4. If we can converge quickly on that, I'd like to queue this quickly and leave it to simmer in -next.

Quoted 8 lines

v7: https://lore.kernel.org/kvmarm/[email protected]/
v6: https://lore.kernel.org/kvmarm/[email protected]/
v5: https://lore.kernel.org/all/[email protected]/
v4: https://lore.kernel.org/kvmarm/[email protected]/
v3: https://lore.kernel.org/r/[email protected]
v2: https://lore.kernel.org/lkml/YyiV%[email protected]/T/
v1: https://lore.kernel.org/lkml/[email protected]

Quoted 4 lines

Testing
=======
(1) kvm/selftests/dirty_log_test
(2) Live migration by QEMU

Could you point to a branch that has the required QEMU changes?

Thanks,

	M.
Signature · 1 line
Without deviation from the norm, progress is not possible.
author
#32 lore raw

Hi Marc,

Quoted 9 lines · Marc Zyngier
Quoted 7 lines · Gavin Shan

This series enables the ring-based dirty memory tracking for ARM64. The feature has been available and enabled on x86 for a while. It is beneficial when the number of dirty pages is small in a checkpointing system or live migration scenario. More details can be found from fb04a1eddb1a ("KVM: X86: Implement ring-based dirty memory tracking").

Quoted 9 lines
Quoted 3 lines

This series is applied to v6.1.rc3, plus commit c227590467cb ("KVM:
Check KVM_CAP_DIRTY_LOG_{RING, RING_ACQ_REL} prior to enabling them"). The commit is currently in Marc's 'fixes' branch, targeting v6.1.rc4/5.

This is starting to look good to me, and my only concerns are around the documentation and the bit of nitpicking on patch 4. If we can converge quickly on that, I'd like to queue this quickly and leave it to simmer in -next.

Ok, thanks.

Quoted 8 lines
Quoted 8 lines

v7: https://lore.kernel.org/kvmarm/[email protected]/
v6: https://lore.kernel.org/kvmarm/[email protected]/
v5: https://lore.kernel.org/all/[email protected]/
v4: https://lore.kernel.org/kvmarm/[email protected]/
v3: https://lore.kernel.org/r/[email protected]
v2: https://lore.kernel.org/lkml/YyiV%[email protected]/T/
v1: https://lore.kernel.org/lkml/[email protected]

Quoted 7 lines
Quoted 4 lines

Testing
=======
(1) kvm/selftests/dirty_log_test
(2) Live migration by QEMU

Could you point to a branch that has the required QEMU changes?

I'm still under progress to figure out migrating the (extra) dirty pages, which is tracked by the backup bitmap. So the branch is pre-mature.

[email protected]:gwshan/qemu.git ("kvm/arm64_dirtyring")

Thanks,
Gavin