Commit 727ae377 authored by Sean Christopherson's avatar Sean Christopherson
Browse files

KVM: x86/mmu: Rename slot rmap walkers to add clarity and clean up code 

Replace "slot_handle_level" with "walk_slot_rmaps" to better capture what
the helpers are doing, and to slightly shorten the function names so that
each function's return type and attributes can be placed on the same line
as the function declaration.

No functional change intended.

Link: https://lore.kernel.org/mm-commits/CAHk-=wjS-Jg7sGMwUPpDsjv392nDOOs0CtUtVkp=S6Q7JzFJRw@mail.gmail.com


Signed-off-by: default avatarBen Gardon <bgardon@google.com>
Link: https://lore.kernel.org/r/20230202182809.1929122-2-bgardon@google.com


Signed-off-by: default avatarSean Christopherson <seanjc@google.com>
parent 9d4655da

arch/x86/kvm/mmu/mmu.c

+33 −33
Original line number Diff line number Diff line
@@ -5902,23 +5902,24 @@ void kvm_configure_mmu(bool enable_tdp, int tdp_forced_root_level, 
EXPORT_SYMBOL_GPL(kvm_configure_mmu);



/* The return value indicates if tlb flush on all vcpus is needed. */

typedef bool (*slot_level_handler) (struct kvm *kvm,

typedef bool (*slot_rmaps_handler) (struct kvm *kvm,

				    struct kvm_rmap_head *rmap_head,

				    const struct kvm_memory_slot *slot);



/* The caller should hold mmu-lock before calling this function. */

static __always_inline bool

slot_handle_level_range(struct kvm *kvm, const struct kvm_memory_slot *memslot,

			slot_level_handler fn, int start_level, int end_level,

			gfn_t start_gfn, gfn_t end_gfn, bool flush_on_yield,

			bool flush)

static __always_inline bool __walk_slot_rmaps(struct kvm *kvm,

					      const struct kvm_memory_slot *slot,

					      slot_rmaps_handler fn,

					      int start_level, int end_level,

					      gfn_t start_gfn, gfn_t end_gfn,

					      bool flush_on_yield, bool flush)

{

	struct slot_rmap_walk_iterator iterator;



	for_each_slot_rmap_range(memslot, start_level, end_level, start_gfn,

	for_each_slot_rmap_range(slot, start_level, end_level, start_gfn,

			end_gfn, &iterator) {

		if (iterator.rmap)

			flush |= fn(kvm, iterator.rmap, memslot);

			flush |= fn(kvm, iterator.rmap, slot);



		if (need_resched() || rwlock_needbreak(&kvm->mmu_lock)) {

			if (flush && flush_on_yield) {
@@ -5933,23 +5934,23 @@ slot_handle_level_range(struct kvm *kvm, const struct kvm_memory_slot *memslot, 
	return flush;

}



static __always_inline bool

slot_handle_level(struct kvm *kvm, const struct kvm_memory_slot *memslot,

		  slot_level_handler fn, int start_level, int end_level,

static __always_inline bool walk_slot_rmaps(struct kvm *kvm,

					    const struct kvm_memory_slot *slot,

					    slot_rmaps_handler fn,

					    int start_level, int end_level,

					    bool flush_on_yield)

{

	return slot_handle_level_range(kvm, memslot, fn, start_level,

			end_level, memslot->base_gfn,

			memslot->base_gfn + memslot->npages - 1,

	return __walk_slot_rmaps(kvm, slot, fn, start_level, end_level,

				 slot->base_gfn, slot->base_gfn + slot->npages - 1,

				 flush_on_yield, false);

}



static __always_inline bool

slot_handle_level_4k(struct kvm *kvm, const struct kvm_memory_slot *memslot,

		     slot_level_handler fn, bool flush_on_yield)

static __always_inline bool walk_slot_rmaps_4k(struct kvm *kvm,

					       const struct kvm_memory_slot *slot,

					       slot_rmaps_handler fn,

					       bool flush_on_yield)

{

	return slot_handle_level(kvm, memslot, fn, PG_LEVEL_4K,

				 PG_LEVEL_4K, flush_on_yield);

	return walk_slot_rmaps(kvm, slot, fn, PG_LEVEL_4K, PG_LEVEL_4K, flush_on_yield);

}



static void free_mmu_pages(struct kvm_mmu *mmu)
@@ -6244,7 +6245,7 @@ static bool kvm_rmap_zap_gfn_range(struct kvm *kvm, gfn_t gfn_start, gfn_t gfn_e 
			if (WARN_ON_ONCE(start >= end))

				continue;



			flush = slot_handle_level_range(kvm, memslot, __kvm_zap_rmap,

			flush = __walk_slot_rmaps(kvm, memslot, __kvm_zap_rmap,

						  PG_LEVEL_4K, KVM_MAX_HUGEPAGE_LEVEL,

						  start, end - 1, true, flush);

		}
@@ -6298,7 +6299,7 @@ void kvm_mmu_slot_remove_write_access(struct kvm *kvm, 
{

	if (kvm_memslots_have_rmaps(kvm)) {

		write_lock(&kvm->mmu_lock);

		slot_handle_level(kvm, memslot, slot_rmap_write_protect,

		walk_slot_rmaps(kvm, memslot, slot_rmap_write_protect,

				start_level, KVM_MAX_HUGEPAGE_LEVEL, false);

		write_unlock(&kvm->mmu_lock);

	}
@@ -6534,11 +6535,10 @@ static void kvm_shadow_mmu_try_split_huge_pages(struct kvm *kvm, 
	 * all the way to the target level. There's no need to split pages

	 * already at the target level.

	 */

	for (level = KVM_MAX_HUGEPAGE_LEVEL; level > target_level; level--) {

		slot_handle_level_range(kvm, slot, shadow_mmu_try_split_huge_pages,

	for (level = KVM_MAX_HUGEPAGE_LEVEL; level > target_level; level--)

		__walk_slot_rmaps(kvm, slot, shadow_mmu_try_split_huge_pages,

				  level, level, start, end - 1, true, false);

}

}



/* Must be called with the mmu_lock held in write-mode. */

void kvm_mmu_try_split_huge_pages(struct kvm *kvm,
@@ -6635,7 +6635,7 @@ static void kvm_rmap_zap_collapsible_sptes(struct kvm *kvm, 
	 * Note, use KVM_MAX_HUGEPAGE_LEVEL - 1 since there's no need to zap

	 * pages that are already mapped at the maximum hugepage level.

	 */

	if (slot_handle_level(kvm, slot, kvm_mmu_zap_collapsible_spte,

	if (walk_slot_rmaps(kvm, slot, kvm_mmu_zap_collapsible_spte,

			    PG_LEVEL_4K, KVM_MAX_HUGEPAGE_LEVEL - 1, true))

		kvm_arch_flush_remote_tlbs_memslot(kvm, slot);

}
@@ -6679,7 +6679,7 @@ void kvm_mmu_slot_leaf_clear_dirty(struct kvm *kvm, 
		 * Clear dirty bits only on 4k SPTEs since the legacy MMU only

		 * support dirty logging at a 4k granularity.

		 */

		slot_handle_level_4k(kvm, memslot, __rmap_clear_dirty, false);

		walk_slot_rmaps_4k(kvm, memslot, __rmap_clear_dirty, false);

		write_unlock(&kvm->mmu_lock);

	}