From 4db3531487bdde4027b701da7c1b8d094ae2cc91 Mon Sep 17 00:00:00 2001 From: Avi Kivity Date: Wed, 21 Nov 2007 15:28:32 +0200 Subject: [PATCH] KVM: MMU: Rename variables of type 'struct kvm_mmu_page *' These are traditionally named 'page', but even more traditionally, that name is reserved for variables that point to a 'struct page'. Rename them to 'sp' (for "shadow page"). Signed-off-by: Avi Kivity --- drivers/kvm/mmu.c | 300 ++++++++++++++++++++++------------------------ 1 file changed, 146 insertions(+), 154 deletions(-) diff --git a/drivers/kvm/mmu.c b/drivers/kvm/mmu.c index 9b75b102b8..86896da3e8 100644 --- a/drivers/kvm/mmu.c +++ b/drivers/kvm/mmu.c @@ -367,7 +367,7 @@ static unsigned long *gfn_to_rmap(struct kvm *kvm, gfn_t gfn) */ static void rmap_add(struct kvm_vcpu *vcpu, u64 *spte, gfn_t gfn) { - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; struct kvm_rmap_desc *desc; unsigned long *rmapp; int i; @@ -375,8 +375,8 @@ static void rmap_add(struct kvm_vcpu *vcpu, u64 *spte, gfn_t gfn) if (!is_rmap_pte(*spte)) return; gfn = unalias_gfn(vcpu->kvm, gfn); - page = page_header(__pa(spte)); - page->gfns[spte - page->spt] = gfn; + sp = page_header(__pa(spte)); + sp->gfns[spte - sp->spt] = gfn; rmapp = gfn_to_rmap(vcpu->kvm, gfn); if (!*rmapp) { rmap_printk("rmap_add: %p %llx 0->1\n", spte, *spte); @@ -429,20 +429,20 @@ static void rmap_remove(struct kvm *kvm, u64 *spte) { struct kvm_rmap_desc *desc; struct kvm_rmap_desc *prev_desc; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; struct page *release_page; unsigned long *rmapp; int i; if (!is_rmap_pte(*spte)) return; - page = page_header(__pa(spte)); + sp = page_header(__pa(spte)); release_page = pfn_to_page((*spte & PT64_BASE_ADDR_MASK) >> PAGE_SHIFT); if (is_writeble_pte(*spte)) kvm_release_page_dirty(release_page); else kvm_release_page_clean(release_page); - rmapp = gfn_to_rmap(kvm, page->gfns[spte - page->spt]); + rmapp = gfn_to_rmap(kvm, sp->gfns[spte - sp->spt]); if (!*rmapp) { printk(KERN_ERR "rmap_remove: %p %llx 0->BUG\n", spte, *spte); BUG(); @@ -537,14 +537,13 @@ static int is_empty_shadow_page(u64 *spt) } #endif -static void kvm_mmu_free_page(struct kvm *kvm, - struct kvm_mmu_page *page_head) +static void kvm_mmu_free_page(struct kvm *kvm, struct kvm_mmu_page *sp) { - ASSERT(is_empty_shadow_page(page_head->spt)); - list_del(&page_head->link); - __free_page(virt_to_page(page_head->spt)); - __free_page(virt_to_page(page_head->gfns)); - kfree(page_head); + ASSERT(is_empty_shadow_page(sp->spt)); + list_del(&sp->link); + __free_page(virt_to_page(sp->spt)); + __free_page(virt_to_page(sp->gfns)); + kfree(sp); ++kvm->n_free_mmu_pages; } @@ -556,27 +555,26 @@ static unsigned kvm_page_table_hashfn(gfn_t gfn) static struct kvm_mmu_page *kvm_mmu_alloc_page(struct kvm_vcpu *vcpu, u64 *parent_pte) { - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; if (!vcpu->kvm->n_free_mmu_pages) return NULL; - page = mmu_memory_cache_alloc(&vcpu->mmu_page_header_cache, - sizeof *page); - page->spt = mmu_memory_cache_alloc(&vcpu->mmu_page_cache, PAGE_SIZE); - page->gfns = mmu_memory_cache_alloc(&vcpu->mmu_page_cache, PAGE_SIZE); - set_page_private(virt_to_page(page->spt), (unsigned long)page); - list_add(&page->link, &vcpu->kvm->active_mmu_pages); - ASSERT(is_empty_shadow_page(page->spt)); - page->slot_bitmap = 0; - page->multimapped = 0; - page->parent_pte = parent_pte; + sp = mmu_memory_cache_alloc(&vcpu->mmu_page_header_cache, sizeof *sp); + sp->spt = mmu_memory_cache_alloc(&vcpu->mmu_page_cache, PAGE_SIZE); + sp->gfns = mmu_memory_cache_alloc(&vcpu->mmu_page_cache, PAGE_SIZE); + set_page_private(virt_to_page(sp->spt), (unsigned long)sp); + list_add(&sp->link, &vcpu->kvm->active_mmu_pages); + ASSERT(is_empty_shadow_page(sp->spt)); + sp->slot_bitmap = 0; + sp->multimapped = 0; + sp->parent_pte = parent_pte; --vcpu->kvm->n_free_mmu_pages; - return page; + return sp; } static void mmu_page_add_parent_pte(struct kvm_vcpu *vcpu, - struct kvm_mmu_page *page, u64 *parent_pte) + struct kvm_mmu_page *sp, u64 *parent_pte) { struct kvm_pte_chain *pte_chain; struct hlist_node *node; @@ -584,20 +582,20 @@ static void mmu_page_add_parent_pte(struct kvm_vcpu *vcpu, if (!parent_pte) return; - if (!page->multimapped) { - u64 *old = page->parent_pte; + if (!sp->multimapped) { + u64 *old = sp->parent_pte; if (!old) { - page->parent_pte = parent_pte; + sp->parent_pte = parent_pte; return; } - page->multimapped = 1; + sp->multimapped = 1; pte_chain = mmu_alloc_pte_chain(vcpu); - INIT_HLIST_HEAD(&page->parent_ptes); - hlist_add_head(&pte_chain->link, &page->parent_ptes); + INIT_HLIST_HEAD(&sp->parent_ptes); + hlist_add_head(&pte_chain->link, &sp->parent_ptes); pte_chain->parent_ptes[0] = old; } - hlist_for_each_entry(pte_chain, node, &page->parent_ptes, link) { + hlist_for_each_entry(pte_chain, node, &sp->parent_ptes, link) { if (pte_chain->parent_ptes[NR_PTE_CHAIN_ENTRIES-1]) continue; for (i = 0; i < NR_PTE_CHAIN_ENTRIES; ++i) @@ -608,23 +606,23 @@ static void mmu_page_add_parent_pte(struct kvm_vcpu *vcpu, } pte_chain = mmu_alloc_pte_chain(vcpu); BUG_ON(!pte_chain); - hlist_add_head(&pte_chain->link, &page->parent_ptes); + hlist_add_head(&pte_chain->link, &sp->parent_ptes); pte_chain->parent_ptes[0] = parent_pte; } -static void mmu_page_remove_parent_pte(struct kvm_mmu_page *page, +static void mmu_page_remove_parent_pte(struct kvm_mmu_page *sp, u64 *parent_pte) { struct kvm_pte_chain *pte_chain; struct hlist_node *node; int i; - if (!page->multimapped) { - BUG_ON(page->parent_pte != parent_pte); - page->parent_pte = NULL; + if (!sp->multimapped) { + BUG_ON(sp->parent_pte != parent_pte); + sp->parent_pte = NULL; return; } - hlist_for_each_entry(pte_chain, node, &page->parent_ptes, link) + hlist_for_each_entry(pte_chain, node, &sp->parent_ptes, link) for (i = 0; i < NR_PTE_CHAIN_ENTRIES; ++i) { if (!pte_chain->parent_ptes[i]) break; @@ -640,9 +638,9 @@ static void mmu_page_remove_parent_pte(struct kvm_mmu_page *page, if (i == 0) { hlist_del(&pte_chain->link); mmu_free_pte_chain(pte_chain); - if (hlist_empty(&page->parent_ptes)) { - page->multimapped = 0; - page->parent_pte = NULL; + if (hlist_empty(&sp->parent_ptes)) { + sp->multimapped = 0; + sp->parent_pte = NULL; } } return; @@ -650,22 +648,21 @@ static void mmu_page_remove_parent_pte(struct kvm_mmu_page *page, BUG(); } -static struct kvm_mmu_page *kvm_mmu_lookup_page(struct kvm *kvm, - gfn_t gfn) +static struct kvm_mmu_page *kvm_mmu_lookup_page(struct kvm *kvm, gfn_t gfn) { unsigned index; struct hlist_head *bucket; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; struct hlist_node *node; pgprintk("%s: looking for gfn %lx\n", __FUNCTION__, gfn); index = kvm_page_table_hashfn(gfn) % KVM_NUM_MMU_PAGES; bucket = &kvm->mmu_page_hash[index]; - hlist_for_each_entry(page, node, bucket, hash_link) - if (page->gfn == gfn && !page->role.metaphysical) { + hlist_for_each_entry(sp, node, bucket, hash_link) + if (sp->gfn == gfn && !sp->role.metaphysical) { pgprintk("%s: found role %x\n", - __FUNCTION__, page->role.word); - return page; + __FUNCTION__, sp->role.word); + return sp; } return NULL; } @@ -682,7 +679,7 @@ static struct kvm_mmu_page *kvm_mmu_get_page(struct kvm_vcpu *vcpu, unsigned index; unsigned quadrant; struct hlist_head *bucket; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; struct hlist_node *node; role.word = 0; @@ -699,35 +696,35 @@ static struct kvm_mmu_page *kvm_mmu_get_page(struct kvm_vcpu *vcpu, gfn, role.word); index = kvm_page_table_hashfn(gfn) % KVM_NUM_MMU_PAGES; bucket = &vcpu->kvm->mmu_page_hash[index]; - hlist_for_each_entry(page, node, bucket, hash_link) - if (page->gfn == gfn && page->role.word == role.word) { - mmu_page_add_parent_pte(vcpu, page, parent_pte); + hlist_for_each_entry(sp, node, bucket, hash_link) + if (sp->gfn == gfn && sp->role.word == role.word) { + mmu_page_add_parent_pte(vcpu, sp, parent_pte); pgprintk("%s: found\n", __FUNCTION__); - return page; + return sp; } - page = kvm_mmu_alloc_page(vcpu, parent_pte); - if (!page) - return page; + sp = kvm_mmu_alloc_page(vcpu, parent_pte); + if (!sp) + return sp; pgprintk("%s: adding gfn %lx role %x\n", __FUNCTION__, gfn, role.word); - page->gfn = gfn; - page->role = role; - hlist_add_head(&page->hash_link, bucket); - vcpu->mmu.prefetch_page(vcpu, page); + sp->gfn = gfn; + sp->role = role; + hlist_add_head(&sp->hash_link, bucket); + vcpu->mmu.prefetch_page(vcpu, sp); if (!metaphysical) rmap_write_protect(vcpu->kvm, gfn); - return page; + return sp; } static void kvm_mmu_page_unlink_children(struct kvm *kvm, - struct kvm_mmu_page *page) + struct kvm_mmu_page *sp) { unsigned i; u64 *pt; u64 ent; - pt = page->spt; + pt = sp->spt; - if (page->role.level == PT_PAGE_TABLE_LEVEL) { + if (sp->role.level == PT_PAGE_TABLE_LEVEL) { for (i = 0; i < PT64_ENT_PER_PAGE; ++i) { if (is_shadow_present_pte(pt[i])) rmap_remove(kvm, &pt[i]); @@ -749,10 +746,9 @@ static void kvm_mmu_page_unlink_children(struct kvm *kvm, kvm_flush_remote_tlbs(kvm); } -static void kvm_mmu_put_page(struct kvm_mmu_page *page, - u64 *parent_pte) +static void kvm_mmu_put_page(struct kvm_mmu_page *sp, u64 *parent_pte) { - mmu_page_remove_parent_pte(page, parent_pte); + mmu_page_remove_parent_pte(sp, parent_pte); } static void kvm_mmu_reset_last_pte_updated(struct kvm *kvm) @@ -764,32 +760,31 @@ static void kvm_mmu_reset_last_pte_updated(struct kvm *kvm) kvm->vcpus[i]->last_pte_updated = NULL; } -static void kvm_mmu_zap_page(struct kvm *kvm, - struct kvm_mmu_page *page) +static void kvm_mmu_zap_page(struct kvm *kvm, struct kvm_mmu_page *sp) { u64 *parent_pte; ++kvm->stat.mmu_shadow_zapped; - while (page->multimapped || page->parent_pte) { - if (!page->multimapped) - parent_pte = page->parent_pte; + while (sp->multimapped || sp->parent_pte) { + if (!sp->multimapped) + parent_pte = sp->parent_pte; else { struct kvm_pte_chain *chain; - chain = container_of(page->parent_ptes.first, + chain = container_of(sp->parent_ptes.first, struct kvm_pte_chain, link); parent_pte = chain->parent_ptes[0]; } BUG_ON(!parent_pte); - kvm_mmu_put_page(page, parent_pte); + kvm_mmu_put_page(sp, parent_pte); set_shadow_pte(parent_pte, shadow_trap_nonpresent_pte); } - kvm_mmu_page_unlink_children(kvm, page); - if (!page->root_count) { - hlist_del(&page->hash_link); - kvm_mmu_free_page(kvm, page); + kvm_mmu_page_unlink_children(kvm, sp); + if (!sp->root_count) { + hlist_del(&sp->hash_link); + kvm_mmu_free_page(kvm, sp); } else - list_move(&page->link, &kvm->active_mmu_pages); + list_move(&sp->link, &kvm->active_mmu_pages); kvm_mmu_reset_last_pte_updated(kvm); } @@ -831,7 +826,7 @@ static int kvm_mmu_unprotect_page(struct kvm *kvm, gfn_t gfn) { unsigned index; struct hlist_head *bucket; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; struct hlist_node *node, *n; int r; @@ -839,11 +834,11 @@ static int kvm_mmu_unprotect_page(struct kvm *kvm, gfn_t gfn) r = 0; index = kvm_page_table_hashfn(gfn) % KVM_NUM_MMU_PAGES; bucket = &kvm->mmu_page_hash[index]; - hlist_for_each_entry_safe(page, node, n, bucket, hash_link) - if (page->gfn == gfn && !page->role.metaphysical) { + hlist_for_each_entry_safe(sp, node, n, bucket, hash_link) + if (sp->gfn == gfn && !sp->role.metaphysical) { pgprintk("%s: gfn %lx role %x\n", __FUNCTION__, gfn, - page->role.word); - kvm_mmu_zap_page(kvm, page); + sp->role.word); + kvm_mmu_zap_page(kvm, sp); r = 1; } return r; @@ -851,21 +846,20 @@ static int kvm_mmu_unprotect_page(struct kvm *kvm, gfn_t gfn) static void mmu_unshadow(struct kvm *kvm, gfn_t gfn) { - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; - while ((page = kvm_mmu_lookup_page(kvm, gfn)) != NULL) { - pgprintk("%s: zap %lx %x\n", - __FUNCTION__, gfn, page->role.word); - kvm_mmu_zap_page(kvm, page); + while ((sp = kvm_mmu_lookup_page(kvm, gfn)) != NULL) { + pgprintk("%s: zap %lx %x\n", __FUNCTION__, gfn, sp->role.word); + kvm_mmu_zap_page(kvm, sp); } } static void page_header_update_slot(struct kvm *kvm, void *pte, gfn_t gfn) { int slot = memslot_id(kvm, gfn_to_memslot(kvm, gfn)); - struct kvm_mmu_page *page_head = page_header(__pa(pte)); + struct kvm_mmu_page *sp = page_header(__pa(pte)); - __set_bit(slot, &page_head->slot_bitmap); + __set_bit(slot, &sp->slot_bitmap); } struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva) @@ -951,7 +945,7 @@ static void nonpaging_prefetch_page(struct kvm_vcpu *vcpu, static void mmu_free_roots(struct kvm_vcpu *vcpu) { int i; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; if (!VALID_PAGE(vcpu->mmu.root_hpa)) return; @@ -959,8 +953,8 @@ static void mmu_free_roots(struct kvm_vcpu *vcpu) if (vcpu->mmu.shadow_root_level == PT64_ROOT_LEVEL) { hpa_t root = vcpu->mmu.root_hpa; - page = page_header(root); - --page->root_count; + sp = page_header(root); + --sp->root_count; vcpu->mmu.root_hpa = INVALID_PAGE; return; } @@ -970,8 +964,8 @@ static void mmu_free_roots(struct kvm_vcpu *vcpu) if (root) { root &= PT64_BASE_ADDR_MASK; - page = page_header(root); - --page->root_count; + sp = page_header(root); + --sp->root_count; } vcpu->mmu.pae_root[i] = INVALID_PAGE; } @@ -982,7 +976,7 @@ static void mmu_alloc_roots(struct kvm_vcpu *vcpu) { int i; gfn_t root_gfn; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; root_gfn = vcpu->cr3 >> PAGE_SHIFT; @@ -991,10 +985,10 @@ static void mmu_alloc_roots(struct kvm_vcpu *vcpu) hpa_t root = vcpu->mmu.root_hpa; ASSERT(!VALID_PAGE(root)); - page = kvm_mmu_get_page(vcpu, root_gfn, 0, - PT64_ROOT_LEVEL, 0, 0, NULL); - root = __pa(page->spt); - ++page->root_count; + sp = kvm_mmu_get_page(vcpu, root_gfn, 0, + PT64_ROOT_LEVEL, 0, 0, NULL); + root = __pa(sp->spt); + ++sp->root_count; vcpu->mmu.root_hpa = root; return; } @@ -1011,11 +1005,11 @@ static void mmu_alloc_roots(struct kvm_vcpu *vcpu) root_gfn = vcpu->pdptrs[i] >> PAGE_SHIFT; } else if (vcpu->mmu.root_level == 0) root_gfn = 0; - page = kvm_mmu_get_page(vcpu, root_gfn, i << 30, - PT32_ROOT_LEVEL, !is_paging(vcpu), - 0, NULL); - root = __pa(page->spt); - ++page->root_count; + sp = kvm_mmu_get_page(vcpu, root_gfn, i << 30, + PT32_ROOT_LEVEL, !is_paging(vcpu), + 0, NULL); + root = __pa(sp->spt); + ++sp->root_count; vcpu->mmu.pae_root[i] = root | PT_PRESENT_MASK; } vcpu->mmu.root_hpa = __pa(vcpu->mmu.pae_root); @@ -1196,7 +1190,7 @@ void kvm_mmu_unload(struct kvm_vcpu *vcpu) } static void mmu_pte_write_zap_pte(struct kvm_vcpu *vcpu, - struct kvm_mmu_page *page, + struct kvm_mmu_page *sp, u64 *spte) { u64 pte; @@ -1204,7 +1198,7 @@ static void mmu_pte_write_zap_pte(struct kvm_vcpu *vcpu, pte = *spte; if (is_shadow_present_pte(pte)) { - if (page->role.level == PT_PAGE_TABLE_LEVEL) + if (sp->role.level == PT_PAGE_TABLE_LEVEL) rmap_remove(vcpu->kvm, spte); else { child = page_header(pte & PT64_BASE_ADDR_MASK); @@ -1215,23 +1209,21 @@ static void mmu_pte_write_zap_pte(struct kvm_vcpu *vcpu, } static void mmu_pte_write_new_pte(struct kvm_vcpu *vcpu, - struct kvm_mmu_page *page, + struct kvm_mmu_page *sp, u64 *spte, const void *new, int bytes, int offset_in_pte) { - if (page->role.level != PT_PAGE_TABLE_LEVEL) { + if (sp->role.level != PT_PAGE_TABLE_LEVEL) { ++vcpu->kvm->stat.mmu_pde_zapped; return; } ++vcpu->kvm->stat.mmu_pte_updated; - if (page->role.glevels == PT32_ROOT_LEVEL) - paging32_update_pte(vcpu, page, spte, new, bytes, - offset_in_pte); + if (sp->role.glevels == PT32_ROOT_LEVEL) + paging32_update_pte(vcpu, sp, spte, new, bytes, offset_in_pte); else - paging64_update_pte(vcpu, page, spte, new, bytes, - offset_in_pte); + paging64_update_pte(vcpu, sp, spte, new, bytes, offset_in_pte); } static bool need_remote_flush(u64 old, u64 new) @@ -1266,7 +1258,7 @@ void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa, const u8 *new, int bytes) { gfn_t gfn = gpa >> PAGE_SHIFT; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; struct hlist_node *node, *n; struct hlist_head *bucket; unsigned index; @@ -1296,10 +1288,10 @@ void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa, } index = kvm_page_table_hashfn(gfn) % KVM_NUM_MMU_PAGES; bucket = &vcpu->kvm->mmu_page_hash[index]; - hlist_for_each_entry_safe(page, node, n, bucket, hash_link) { - if (page->gfn != gfn || page->role.metaphysical) + hlist_for_each_entry_safe(sp, node, n, bucket, hash_link) { + if (sp->gfn != gfn || sp->role.metaphysical) continue; - pte_size = page->role.glevels == PT32_ROOT_LEVEL ? 4 : 8; + pte_size = sp->role.glevels == PT32_ROOT_LEVEL ? 4 : 8; misaligned = (offset ^ (offset + bytes - 1)) & ~(pte_size - 1); misaligned |= bytes < 4; if (misaligned || flooded) { @@ -1314,15 +1306,15 @@ void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa, * page. */ pgprintk("misaligned: gpa %llx bytes %d role %x\n", - gpa, bytes, page->role.word); - kvm_mmu_zap_page(vcpu->kvm, page); + gpa, bytes, sp->role.word); + kvm_mmu_zap_page(vcpu->kvm, sp); ++vcpu->kvm->stat.mmu_flooded; continue; } page_offset = offset; - level = page->role.level; + level = sp->role.level; npte = 1; - if (page->role.glevels == PT32_ROOT_LEVEL) { + if (sp->role.glevels == PT32_ROOT_LEVEL) { page_offset <<= 1; /* 32->64 */ /* * A 32-bit pde maps 4MB while the shadow pdes map @@ -1336,14 +1328,14 @@ void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa, } quadrant = page_offset >> PAGE_SHIFT; page_offset &= ~PAGE_MASK; - if (quadrant != page->role.quadrant) + if (quadrant != sp->role.quadrant) continue; } - spte = &page->spt[page_offset / sizeof(*spte)]; + spte = &sp->spt[page_offset / sizeof(*spte)]; while (npte--) { entry = *spte; - mmu_pte_write_zap_pte(vcpu, page, spte); - mmu_pte_write_new_pte(vcpu, page, spte, new, bytes, + mmu_pte_write_zap_pte(vcpu, sp, spte); + mmu_pte_write_new_pte(vcpu, sp, spte, new, bytes, page_offset & (pte_size - 1)); mmu_pte_write_flush_tlb(vcpu, entry, *spte); ++spte; @@ -1362,11 +1354,11 @@ int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva) void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu) { while (vcpu->kvm->n_free_mmu_pages < KVM_REFILL_PAGES) { - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; - page = container_of(vcpu->kvm->active_mmu_pages.prev, - struct kvm_mmu_page, link); - kvm_mmu_zap_page(vcpu->kvm, page); + sp = container_of(vcpu->kvm->active_mmu_pages.prev, + struct kvm_mmu_page, link); + kvm_mmu_zap_page(vcpu->kvm, sp); ++vcpu->kvm->stat.mmu_recycled; } } @@ -1413,12 +1405,12 @@ EXPORT_SYMBOL_GPL(kvm_mmu_page_fault); static void free_mmu_pages(struct kvm_vcpu *vcpu) { - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; while (!list_empty(&vcpu->kvm->active_mmu_pages)) { - page = container_of(vcpu->kvm->active_mmu_pages.next, - struct kvm_mmu_page, link); - kvm_mmu_zap_page(vcpu->kvm, page); + sp = container_of(vcpu->kvm->active_mmu_pages.next, + struct kvm_mmu_page, link); + kvm_mmu_zap_page(vcpu->kvm, sp); } free_page((unsigned long)vcpu->mmu.pae_root); } @@ -1480,16 +1472,16 @@ void kvm_mmu_destroy(struct kvm_vcpu *vcpu) void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot) { - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; - list_for_each_entry(page, &kvm->active_mmu_pages, link) { + list_for_each_entry(sp, &kvm->active_mmu_pages, link) { int i; u64 *pt; - if (!test_bit(slot, &page->slot_bitmap)) + if (!test_bit(slot, &sp->slot_bitmap)) continue; - pt = page->spt; + pt = sp->spt; for (i = 0; i < PT64_ENT_PER_PAGE; ++i) /* avoid RMW */ if (pt[i] & PT_WRITABLE_MASK) @@ -1499,10 +1491,10 @@ void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot) void kvm_mmu_zap_all(struct kvm *kvm) { - struct kvm_mmu_page *page, *node; + struct kvm_mmu_page *sp, *node; - list_for_each_entry_safe(page, node, &kvm->active_mmu_pages, link) - kvm_mmu_zap_page(kvm, page); + list_for_each_entry_safe(sp, node, &kvm->active_mmu_pages, link) + kvm_mmu_zap_page(kvm, sp); kvm_flush_remote_tlbs(kvm); } @@ -1668,13 +1660,13 @@ static int count_rmaps(struct kvm_vcpu *vcpu) static int count_writable_mappings(struct kvm_vcpu *vcpu) { int nmaps = 0; - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; int i; - list_for_each_entry(page, &vcpu->kvm->active_mmu_pages, link) { - u64 *pt = page->spt; + list_for_each_entry(sp, &vcpu->kvm->active_mmu_pages, link) { + u64 *pt = sp->spt; - if (page->role.level != PT_PAGE_TABLE_LEVEL) + if (sp->role.level != PT_PAGE_TABLE_LEVEL) continue; for (i = 0; i < PT64_ENT_PER_PAGE; ++i) { @@ -1702,23 +1694,23 @@ static void audit_rmap(struct kvm_vcpu *vcpu) static void audit_write_protection(struct kvm_vcpu *vcpu) { - struct kvm_mmu_page *page; + struct kvm_mmu_page *sp; struct kvm_memory_slot *slot; unsigned long *rmapp; gfn_t gfn; - list_for_each_entry(page, &vcpu->kvm->active_mmu_pages, link) { - if (page->role.metaphysical) + list_for_each_entry(sp, &vcpu->kvm->active_mmu_pages, link) { + if (sp->role.metaphysical) continue; - slot = gfn_to_memslot(vcpu->kvm, page->gfn); - gfn = unalias_gfn(vcpu->kvm, page->gfn); + slot = gfn_to_memslot(vcpu->kvm, sp->gfn); + gfn = unalias_gfn(vcpu->kvm, sp->gfn); rmapp = &slot->rmap[gfn - slot->base_gfn]; if (*rmapp) printk(KERN_ERR "%s: (%s) shadow page has writable" " mappings: gfn %lx role %x\n", - __FUNCTION__, audit_msg, page->gfn, - page->role.word); + __FUNCTION__, audit_msg, sp->gfn, + sp->role.word); } } -- 2.39.5