Use "mask" instead of a dedicated boolean to track whether or not there
is at least one to-be-reset entry for the current slot+offset. In the
body of the loop, mask is zero only on the first iteration, i.e. !mask is
equivalent to first_round.
Opportunistically combine the adjacent "if (mask)" statements into a single
if-statement.
No functional change intended.
Cc: Peter Xu <peterx@redhat.com>
Cc: Yan Zhao <yan.y.zhao@intel.com>
Cc: Maxim Levitsky <mlevitsk@redhat.com>
Reviewed-by: Pankaj Gupta <pankaj.gupta@amd.com>
Reviewed-by: James Houghton <jthoughton@google.com>
Signed-off-by: Sean Christopherson <seanjc@google.com>
---
virt/kvm/dirty_ring.c | 60 +++++++++++++++++++++----------------------
1 file changed, 29 insertions(+), 31 deletions(-)
diff --git a/virt/kvm/dirty_ring.c b/virt/kvm/dirty_ring.c
index 84c75483a089..54734025658a 100644
--- a/virt/kvm/dirty_ring.c
+++ b/virt/kvm/dirty_ring.c
@@ -121,7 +121,6 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
u64 cur_offset, next_offset;
unsigned long mask = 0;
struct kvm_dirty_gfn *entry;
- bool first_round = true;
while (likely((*nr_entries_reset) < INT_MAX)) {
if (signal_pending(current))
@@ -141,42 +140,42 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
ring->reset_index++;
(*nr_entries_reset)++;
- /*
- * While the size of each ring is fixed, it's possible for the
- * ring to be constantly re-dirtied/harvested while the reset
- * is in-progress (the hard limit exists only to guard against
- * wrapping the count into negative space).
- */
- if (!first_round)
+ if (mask) {
+ /*
+ * While the size of each ring is fixed, it's possible
+ * for the ring to be constantly re-dirtied/harvested
+ * while the reset is in-progress (the hard limit exists
+ * only to guard against the count becoming negative).
+ */
cond_resched();
- /*
- * Try to coalesce the reset operations when the guest is
- * scanning pages in the same slot.
- */
- if (!first_round && next_slot == cur_slot) {
- s64 delta = next_offset - cur_offset;
+ /*
+ * Try to coalesce the reset operations when the guest
+ * is scanning pages in the same slot.
+ */
+ if (next_slot == cur_slot) {
+ s64 delta = next_offset - cur_offset;
- if (delta >= 0 && delta < BITS_PER_LONG) {
- mask |= 1ull << delta;
- continue;
- }
+ if (delta >= 0 && delta < BITS_PER_LONG) {
+ mask |= 1ull << delta;
+ continue;
+ }
- /* Backwards visit, careful about overflows! */
- if (delta > -BITS_PER_LONG && delta < 0 &&
- (mask << -delta >> -delta) == mask) {
- cur_offset = next_offset;
- mask = (mask << -delta) | 1;
- continue;
+ /* Backwards visit, careful about overflows! */
+ if (delta > -BITS_PER_LONG && delta < 0 &&
+ (mask << -delta >> -delta) == mask) {
+ cur_offset = next_offset;
+ mask = (mask << -delta) | 1;
+ continue;
+ }
}
- }
- /*
- * Reset the slot for all the harvested entries that have been
- * gathered, but not yet fully processed.
- */
- if (mask)
+ /*
+ * Reset the slot for all the harvested entries that
+ * have been gathered, but not yet fully processed.
+ */
kvm_reset_dirty_gfn(kvm, cur_slot, cur_offset, mask);
+ }
/*
* The current slot was reset or this is the first harvested
@@ -185,7 +184,6 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
cur_slot = next_slot;
cur_offset = next_offset;
mask = 1;
- first_round = false;
}
/*
--
2.49.0.1112.g889b7c5bd8-googOn Fri, May 16, 2025 at 02:35:39PM -0700, Sean Christopherson wrote:
> Use "mask" instead of a dedicated boolean to track whether or not there
> is at least one to-be-reset entry for the current slot+offset. In the
> body of the loop, mask is zero only on the first iteration, i.e. !mask is
> equivalent to first_round.
>
> Opportunistically combine the adjacent "if (mask)" statements into a single
> if-statement.
>
> No functional change intended.
>
> Cc: Peter Xu <peterx@redhat.com>
> Cc: Yan Zhao <yan.y.zhao@intel.com>
> Cc: Maxim Levitsky <mlevitsk@redhat.com>
> Reviewed-by: Pankaj Gupta <pankaj.gupta@amd.com>
> Reviewed-by: James Houghton <jthoughton@google.com>
> Signed-off-by: Sean Christopherson <seanjc@google.com>
> ---
> virt/kvm/dirty_ring.c | 60 +++++++++++++++++++++----------------------
> 1 file changed, 29 insertions(+), 31 deletions(-)
>
> diff --git a/virt/kvm/dirty_ring.c b/virt/kvm/dirty_ring.c
> index 84c75483a089..54734025658a 100644
> --- a/virt/kvm/dirty_ring.c
> +++ b/virt/kvm/dirty_ring.c
> @@ -121,7 +121,6 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> u64 cur_offset, next_offset;
> unsigned long mask = 0;
> struct kvm_dirty_gfn *entry;
> - bool first_round = true;
>
> while (likely((*nr_entries_reset) < INT_MAX)) {
> if (signal_pending(current))
> @@ -141,42 +140,42 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> ring->reset_index++;
> (*nr_entries_reset)++;
>
> - /*
> - * While the size of each ring is fixed, it's possible for the
> - * ring to be constantly re-dirtied/harvested while the reset
> - * is in-progress (the hard limit exists only to guard against
> - * wrapping the count into negative space).
> - */
> - if (!first_round)
> + if (mask) {
> + /*
> + * While the size of each ring is fixed, it's possible
> + * for the ring to be constantly re-dirtied/harvested
> + * while the reset is in-progress (the hard limit exists
> + * only to guard against the count becoming negative).
> + */
> cond_resched();
>
> - /*
> - * Try to coalesce the reset operations when the guest is
> - * scanning pages in the same slot.
> - */
> - if (!first_round && next_slot == cur_slot) {
> - s64 delta = next_offset - cur_offset;
> + /*
> + * Try to coalesce the reset operations when the guest
> + * is scanning pages in the same slot.
> + */
> + if (next_slot == cur_slot) {
> + s64 delta = next_offset - cur_offset;
>
> - if (delta >= 0 && delta < BITS_PER_LONG) {
> - mask |= 1ull << delta;
> - continue;
> - }
> + if (delta >= 0 && delta < BITS_PER_LONG) {
> + mask |= 1ull << delta;
> + continue;
> + }
>
> - /* Backwards visit, careful about overflows! */
> - if (delta > -BITS_PER_LONG && delta < 0 &&
> - (mask << -delta >> -delta) == mask) {
> - cur_offset = next_offset;
> - mask = (mask << -delta) | 1;
> - continue;
> + /* Backwards visit, careful about overflows! */
> + if (delta > -BITS_PER_LONG && delta < 0 &&
> + (mask << -delta >> -delta) == mask) {
> + cur_offset = next_offset;
> + mask = (mask << -delta) | 1;
> + continue;
> + }
> }
> - }
>
> - /*
> - * Reset the slot for all the harvested entries that have been
> - * gathered, but not yet fully processed.
> - */
> - if (mask)
> + /*
> + * Reset the slot for all the harvested entries that
> + * have been gathered, but not yet fully processed.
> + */
> kvm_reset_dirty_gfn(kvm, cur_slot, cur_offset, mask);
Nit and feel free to ignore it :)
Would it be better to move the "cond_resched()" to here, i.e., executing it for
at most every 64 entries?
> + }
>
> /*
> * The current slot was reset or this is the first harvested
> @@ -185,7 +184,6 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> cur_slot = next_slot;
> cur_offset = next_offset;
> mask = 1;
> - first_round = false;
> }
>
> /*
> --
> 2.49.0.1112.g889b7c5bd8-goog
>
On Wed, May 21, 2025, Yan Zhao wrote:
> On Fri, May 16, 2025 at 02:35:39PM -0700, Sean Christopherson wrote:
> > @@ -141,42 +140,42 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> > ring->reset_index++;
> > (*nr_entries_reset)++;
> >
> > - /*
> > - * While the size of each ring is fixed, it's possible for the
> > - * ring to be constantly re-dirtied/harvested while the reset
> > - * is in-progress (the hard limit exists only to guard against
> > - * wrapping the count into negative space).
> > - */
> > - if (!first_round)
> > + if (mask) {
> > + /*
> > + * While the size of each ring is fixed, it's possible
> > + * for the ring to be constantly re-dirtied/harvested
> > + * while the reset is in-progress (the hard limit exists
> > + * only to guard against the count becoming negative).
> > + */
> > cond_resched();
> >
> > - /*
> > - * Try to coalesce the reset operations when the guest is
> > - * scanning pages in the same slot.
> > - */
> > - if (!first_round && next_slot == cur_slot) {
> > - s64 delta = next_offset - cur_offset;
> > + /*
> > + * Try to coalesce the reset operations when the guest
> > + * is scanning pages in the same slot.
> > + */
> > + if (next_slot == cur_slot) {
> > + s64 delta = next_offset - cur_offset;
> >
> > - if (delta >= 0 && delta < BITS_PER_LONG) {
> > - mask |= 1ull << delta;
> > - continue;
> > - }
> > + if (delta >= 0 && delta < BITS_PER_LONG) {
> > + mask |= 1ull << delta;
> > + continue;
> > + }
> >
> > - /* Backwards visit, careful about overflows! */
> > - if (delta > -BITS_PER_LONG && delta < 0 &&
> > - (mask << -delta >> -delta) == mask) {
> > - cur_offset = next_offset;
> > - mask = (mask << -delta) | 1;
> > - continue;
> > + /* Backwards visit, careful about overflows! */
> > + if (delta > -BITS_PER_LONG && delta < 0 &&
> > + (mask << -delta >> -delta) == mask) {
> > + cur_offset = next_offset;
> > + mask = (mask << -delta) | 1;
> > + continue;
> > + }
> > }
> > - }
> >
> > - /*
> > - * Reset the slot for all the harvested entries that have been
> > - * gathered, but not yet fully processed.
> > - */
> > - if (mask)
> > + /*
> > + * Reset the slot for all the harvested entries that
> > + * have been gathered, but not yet fully processed.
> > + */
> > kvm_reset_dirty_gfn(kvm, cur_slot, cur_offset, mask);
> Nit and feel free to ignore it :)
>
> Would it be better to move the "cond_resched()" to here, i.e., executing it for
> at most every 64 entries?
Hmm, yeah, I think that makes sense. The time spent manipulating the ring and
mask+offset is quite trivial, so checking on every single entry is unnecessary.
On Wed, May 21, 2025, Sean Christopherson wrote:
> On Wed, May 21, 2025, Yan Zhao wrote:
> > On Fri, May 16, 2025 at 02:35:39PM -0700, Sean Christopherson wrote:
> > > @@ -141,42 +140,42 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> > > ring->reset_index++;
> > > (*nr_entries_reset)++;
> > >
> > > - /*
> > > - * While the size of each ring is fixed, it's possible for the
> > > - * ring to be constantly re-dirtied/harvested while the reset
> > > - * is in-progress (the hard limit exists only to guard against
> > > - * wrapping the count into negative space).
> > > - */
> > > - if (!first_round)
> > > + if (mask) {
> > > + /*
> > > + * While the size of each ring is fixed, it's possible
> > > + * for the ring to be constantly re-dirtied/harvested
> > > + * while the reset is in-progress (the hard limit exists
> > > + * only to guard against the count becoming negative).
> > > + */
> > > cond_resched();
> > >
> > > - /*
> > > - * Try to coalesce the reset operations when the guest is
> > > - * scanning pages in the same slot.
> > > - */
> > > - if (!first_round && next_slot == cur_slot) {
> > > - s64 delta = next_offset - cur_offset;
> > > + /*
> > > + * Try to coalesce the reset operations when the guest
> > > + * is scanning pages in the same slot.
> > > + */
> > > + if (next_slot == cur_slot) {
> > > + s64 delta = next_offset - cur_offset;
> > >
> > > - if (delta >= 0 && delta < BITS_PER_LONG) {
> > > - mask |= 1ull << delta;
> > > - continue;
> > > - }
> > > + if (delta >= 0 && delta < BITS_PER_LONG) {
> > > + mask |= 1ull << delta;
> > > + continue;
> > > + }
> > >
> > > - /* Backwards visit, careful about overflows! */
> > > - if (delta > -BITS_PER_LONG && delta < 0 &&
> > > - (mask << -delta >> -delta) == mask) {
> > > - cur_offset = next_offset;
> > > - mask = (mask << -delta) | 1;
> > > - continue;
> > > + /* Backwards visit, careful about overflows! */
> > > + if (delta > -BITS_PER_LONG && delta < 0 &&
> > > + (mask << -delta >> -delta) == mask) {
> > > + cur_offset = next_offset;
> > > + mask = (mask << -delta) | 1;
> > > + continue;
> > > + }
> > > }
> > > - }
> > >
> > > - /*
> > > - * Reset the slot for all the harvested entries that have been
> > > - * gathered, but not yet fully processed.
> > > - */
> > > - if (mask)
> > > + /*
> > > + * Reset the slot for all the harvested entries that
> > > + * have been gathered, but not yet fully processed.
> > > + */
> > > kvm_reset_dirty_gfn(kvm, cur_slot, cur_offset, mask);
> > Nit and feel free to ignore it :)
> >
> > Would it be better to move the "cond_resched()" to here, i.e., executing it for
> > at most every 64 entries?
>
> Hmm, yeah, I think that makes sense. The time spent manipulating the ring and
> mask+offset is quite trivial, so checking on every single entry is unnecessary.
Oh, no, scratch that. Thankfully, past me explicitly documented this. From
patch 3:
Note! Take care to check for reschedule even in the "continue" paths,
as a pathological scenario (or malicious userspace) could dirty the same
gfn over and over, i.e. always hit the continue path.
A batch isn't guaranteed to be flushed after processing 64 entries, it's only
flushed when an entry more than N gfns away is encountered.
On Wed, May 21, 2025 at 12:45:44PM -0700, Sean Christopherson wrote:
> On Wed, May 21, 2025, Sean Christopherson wrote:
> > On Wed, May 21, 2025, Yan Zhao wrote:
> > > On Fri, May 16, 2025 at 02:35:39PM -0700, Sean Christopherson wrote:
> > > > @@ -141,42 +140,42 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> > > > ring->reset_index++;
> > > > (*nr_entries_reset)++;
> > > >
> > > > - /*
> > > > - * While the size of each ring is fixed, it's possible for the
> > > > - * ring to be constantly re-dirtied/harvested while the reset
> > > > - * is in-progress (the hard limit exists only to guard against
> > > > - * wrapping the count into negative space).
> > > > - */
> > > > - if (!first_round)
> > > > + if (mask) {
> > > > + /*
> > > > + * While the size of each ring is fixed, it's possible
> > > > + * for the ring to be constantly re-dirtied/harvested
> > > > + * while the reset is in-progress (the hard limit exists
> > > > + * only to guard against the count becoming negative).
> > > > + */
> > > > cond_resched();
> > > >
> > > > - /*
> > > > - * Try to coalesce the reset operations when the guest is
> > > > - * scanning pages in the same slot.
> > > > - */
> > > > - if (!first_round && next_slot == cur_slot) {
> > > > - s64 delta = next_offset - cur_offset;
> > > > + /*
> > > > + * Try to coalesce the reset operations when the guest
> > > > + * is scanning pages in the same slot.
> > > > + */
> > > > + if (next_slot == cur_slot) {
> > > > + s64 delta = next_offset - cur_offset;
> > > >
> > > > - if (delta >= 0 && delta < BITS_PER_LONG) {
> > > > - mask |= 1ull << delta;
> > > > - continue;
> > > > - }
> > > > + if (delta >= 0 && delta < BITS_PER_LONG) {
> > > > + mask |= 1ull << delta;
> > > > + continue;
> > > > + }
> > > >
> > > > - /* Backwards visit, careful about overflows! */
> > > > - if (delta > -BITS_PER_LONG && delta < 0 &&
> > > > - (mask << -delta >> -delta) == mask) {
> > > > - cur_offset = next_offset;
> > > > - mask = (mask << -delta) | 1;
> > > > - continue;
> > > > + /* Backwards visit, careful about overflows! */
> > > > + if (delta > -BITS_PER_LONG && delta < 0 &&
> > > > + (mask << -delta >> -delta) == mask) {
> > > > + cur_offset = next_offset;
> > > > + mask = (mask << -delta) | 1;
> > > > + continue;
> > > > + }
> > > > }
> > > > - }
> > > >
> > > > - /*
> > > > - * Reset the slot for all the harvested entries that have been
> > > > - * gathered, but not yet fully processed.
> > > > - */
> > > > - if (mask)
> > > > + /*
> > > > + * Reset the slot for all the harvested entries that
> > > > + * have been gathered, but not yet fully processed.
> > > > + */
> > > > kvm_reset_dirty_gfn(kvm, cur_slot, cur_offset, mask);
> > > Nit and feel free to ignore it :)
> > >
> > > Would it be better to move the "cond_resched()" to here, i.e., executing it for
> > > at most every 64 entries?
> >
> > Hmm, yeah, I think that makes sense. The time spent manipulating the ring and
> > mask+offset is quite trivial, so checking on every single entry is unnecessary.
>
> Oh, no, scratch that. Thankfully, past me explicitly documented this. From
> patch 3:
>
> Note! Take care to check for reschedule even in the "continue" paths,
> as a pathological scenario (or malicious userspace) could dirty the same
> gfn over and over, i.e. always hit the continue path.
>
> A batch isn't guaranteed to be flushed after processing 64 entries, it's only
> flushed when an entry more than N gfns away is encountered.
Oh, I overlooked the "pathological scenario". You are right!
On 5/17/2025 5:35 AM, Sean Christopherson wrote:
> Use "mask" instead of a dedicated boolean to track whether or not there
> is at least one to-be-reset entry for the current slot+offset. In the
> body of the loop, mask is zero only on the first iteration, i.e. !mask is
> equivalent to first_round.
>
> Opportunistically combine the adjacent "if (mask)" statements into a single
> if-statement.
>
> No functional change intended.
>
> Cc: Peter Xu <peterx@redhat.com>
> Cc: Yan Zhao <yan.y.zhao@intel.com>
> Cc: Maxim Levitsky <mlevitsk@redhat.com>
> Reviewed-by: Pankaj Gupta <pankaj.gupta@amd.com>
> Reviewed-by: James Houghton <jthoughton@google.com>
> Signed-off-by: Sean Christopherson <seanjc@google.com>
Reviewed-by: Binbin Wu <binbin.wu@linux.intel.com>
> ---
> virt/kvm/dirty_ring.c | 60 +++++++++++++++++++++----------------------
> 1 file changed, 29 insertions(+), 31 deletions(-)
>
> diff --git a/virt/kvm/dirty_ring.c b/virt/kvm/dirty_ring.c
> index 84c75483a089..54734025658a 100644
> --- a/virt/kvm/dirty_ring.c
> +++ b/virt/kvm/dirty_ring.c
> @@ -121,7 +121,6 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> u64 cur_offset, next_offset;
> unsigned long mask = 0;
> struct kvm_dirty_gfn *entry;
> - bool first_round = true;
>
> while (likely((*nr_entries_reset) < INT_MAX)) {
> if (signal_pending(current))
> @@ -141,42 +140,42 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> ring->reset_index++;
> (*nr_entries_reset)++;
>
> - /*
> - * While the size of each ring is fixed, it's possible for the
> - * ring to be constantly re-dirtied/harvested while the reset
> - * is in-progress (the hard limit exists only to guard against
> - * wrapping the count into negative space).
> - */
> - if (!first_round)
> + if (mask) {
> + /*
> + * While the size of each ring is fixed, it's possible
> + * for the ring to be constantly re-dirtied/harvested
> + * while the reset is in-progress (the hard limit exists
> + * only to guard against the count becoming negative).
> + */
> cond_resched();
>
> - /*
> - * Try to coalesce the reset operations when the guest is
> - * scanning pages in the same slot.
> - */
> - if (!first_round && next_slot == cur_slot) {
> - s64 delta = next_offset - cur_offset;
> + /*
> + * Try to coalesce the reset operations when the guest
> + * is scanning pages in the same slot.
> + */
> + if (next_slot == cur_slot) {
> + s64 delta = next_offset - cur_offset;
>
> - if (delta >= 0 && delta < BITS_PER_LONG) {
> - mask |= 1ull << delta;
> - continue;
> - }
> + if (delta >= 0 && delta < BITS_PER_LONG) {
> + mask |= 1ull << delta;
> + continue;
> + }
>
> - /* Backwards visit, careful about overflows! */
> - if (delta > -BITS_PER_LONG && delta < 0 &&
> - (mask << -delta >> -delta) == mask) {
> - cur_offset = next_offset;
> - mask = (mask << -delta) | 1;
> - continue;
> + /* Backwards visit, careful about overflows! */
> + if (delta > -BITS_PER_LONG && delta < 0 &&
> + (mask << -delta >> -delta) == mask) {
> + cur_offset = next_offset;
> + mask = (mask << -delta) | 1;
> + continue;
> + }
> }
> - }
>
> - /*
> - * Reset the slot for all the harvested entries that have been
> - * gathered, but not yet fully processed.
> - */
> - if (mask)
> + /*
> + * Reset the slot for all the harvested entries that
> + * have been gathered, but not yet fully processed.
> + */
> kvm_reset_dirty_gfn(kvm, cur_slot, cur_offset, mask);
> + }
>
> /*
> * The current slot was reset or this is the first harvested
> @@ -185,7 +184,6 @@ int kvm_dirty_ring_reset(struct kvm *kvm, struct kvm_dirty_ring *ring,
> cur_slot = next_slot;
> cur_offset = next_offset;
> mask = 1;
> - first_round = false;
> }
>
> /*
© 2016 - 2025 Red Hat, Inc.