patch mmu KVM_API_VERSION = 12

rtable

1. 
   
2. static int is_largepage_backed(struct kvm_vcpu *vcpu, gfn_t large_gfn)
   
3. {
   
4.         struct kvm_memory_slot *slot;
   
5. +        gfn_t gfn = large_gfn;
   
6. +
   
7. +        gfn = unalias_gfn(vcpu->kvm, gfn);
   
8. +        slot = gfn_to_memslot_unaliased(vcpu->kvm, gfn);
   
9. +        if (slot) {
   
10. +                int *idx = slot_largepage_idx(gfn, slot);
    
11. +                if (*idx || slot->dirty_bitmap)               
    
12. +                        return 0;
    
13. +        }
    
14. -        if (has_wrprotected_page(vcpu->kvm, large_gfn))
    
15. -                return 0;
    
16. 
    
17.         if (! host_largepage_backed(vcpu->kvm, large_gfn))
    
18.                 return 0;
    
19. 
    
20. -        slot = gfn_to_memslot(vcpu->kvm, large_gfn);
    
21. -        if (slot && slot->dirty_bitmap)
    
22. -                return 0;
    
23. 
    
24.         return 1;
    
25. }
    

复制代码

rtable

1. 
   
2. static unsigned long * gfn_to_rmap(struct kvm *kvm, gfn_t gfn, int lpage)
   
3. {
   
4.         struct kvm_memory_slot *slot;
   
5.         unsigned long idx;
   
6. 
   
7.         slot = gfn_to_memslot(kvm, gfn);
   
8. +        BUG_ON(! slot);
   
9.         if (! lpage)
   
10.                 return &slot->rmap[gfn - slot->base_gfn];
    
11. 
    
12. -        idx = (gfn / KVM_PAGES_PER_HPAGE) -
    
13. -              (slot->base_gfn / KVM_PAGES_PER_HPAGE);
    
14. +        idx = (gfn - slot->base_gfn) / KVM_PAGES_PER_HPAGE;
    
15. 
    
16.         return &slot->lpage_info[idx].rmap_pde;
    
17. }
    

复制代码

rtable

1. 
   
2. static int kvm_mmu_zap_page(struct kvm *kvm, struct kvm_mmu_page *sp)
   
3. {
   
4.         int ret;
   
5. 
   
6.         ++kvm->stat.mmu_shadow_zapped;
   
7. 
   
8.         ret = mmu_zap_unsync_children(kvm, sp);
   
9.         kvm_mmu_page_unlink_children(kvm, sp);
   
10.         kvm_mmu_unlink_parents(kvm, sp);
    
11. 
    
12.         kvm_flush_remote_tlbs(kvm);
    
13. 
    
14.         if (!sp->role.invalid && !sp->role.direct)
    
15.                 unaccount_shadowed(kvm, sp->gfn);
    
16. 
    
17.         if (sp->unsync)
    
18.                 kvm_unlink_unsync_page(kvm, sp);
    
19. 
    
20.         if (! sp->root_count) {
    
21.                 hlist_del(&sp->hash_link);
    
22.                 kvm_mmu_free_page(kvm, sp);
    
23. +                ++ret;
    
24.         }
    
25.         else {
    
26.                 sp->role.invalid = 1;
    
27.                 list_move(&sp->link, &kvm->arch.active_mmu_pages);
    
28.                
    
29.                 kvm_reload_remote_mmus(kvm);
    
30.         }
    
31. 
    
32.         kvm_mmu_reset_last_pte_updated(kvm);
    
33.         return ret;
    
34. }
    

复制代码

rtable

1. 
   
2. void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages)
   
3. {
   
4.         int used_pages;
   
5. 
   
6.         used_pages = kvm->arch.n_alloc_mmu_pages - kvm->arch.n_free_mmu_pages;
   
7.         used_pages = max(0, used_pages);
   
8. 
   
9.         /*
   
10.          * If we set the number of mmu pages to be smaller be than the
    
11.          * number of actived pages , we must to free some mmu pages before we
    
12.          * change the value
    
13.          */
    
14. 
    
15.         if (used_pages > kvm_nr_mmu_pages) {
    
16.                 while (used_pages > kvm_nr_mmu_pages) {
    
17.                         struct kvm_mmu_page *page;
    
18. 
    
19.                         page = container_of(kvm->arch.active_mmu_pages.prev, struct kvm_mmu_page, link);
    
20. -                        kvm_mmu_zap_page(kvm, page);
    
21. -                        used_pages--;
    
22. +                        //still dead loop?
    
23. +                        used_pages -= kvm_mmu_zap_page(kvm, page);
    
24.                 }
    
25.                 kvm->arch.n_free_mmu_pages = 0;
    
26.         }
    
27.         else
    
28.                 kvm->arch.n_free_mmu_pages += kvm_nr_mmu_pages - kvm->arch.n_alloc_mmu_pages;
    
29. 
    
30.         kvm->arch.n_alloc_mmu_pages = kvm_nr_mmu_pages;
    
31. }
    
32. 
    

复制代码

[ 本帖最后由 rtable 于 2009-12-6 17:20 编辑 ]

Godbach

建议LZ对Patch做一些说明

rtable

cool kvm http://lkml.org/lkml/2009/11/16/71

T-Bagwell

楼主把patch发到这里想说明什么呢？