bug in KVM mmu.c 2.6.31-rc9

rtable

1. 
   
2. static void mmu_set_spte(struct kvm_vcpu *vcpu, u64 *shadow_pte,
   
3.                          unsigned pt_access, unsigned pte_access,
   
4.                          int user_fault, int write_fault, int dirty,
   
5.                          int *ptwrite, int largepage, gfn_t gfn,
   
6.                          pfn_t pfn, bool speculative)
   
7. {
   
8.         int was_rmapped = 0;
   
9.         int was_writeble = is_writeble_pte(*shadow_pte);
   
10.         int rmap_count;
    
11. 
    
12.         pgprintk("%s: spte %llx access %x write_fault %d"
    
13.                  " user_fault %d gfn %lx\n",
    
14.                  __func__, *shadow_pte, pt_access,
    
15.                  write_fault, user_fault, gfn);
    
16. 
    
17.         if (is_rmap_pte(*shadow_pte)) {
    
18.                 /*
    
19.                  * If we overwrite a PTE page pointer with a 2MB PMD, unlink
    
20.                  * the parent of the now unreachable PTE.
    
21.                  */
    
22.                 if (largepage && !is_large_pte(*shadow_pte)) {
    
23.                         struct kvm_mmu_page *child;
    
24.                         u64 pte = *shadow_pte;
    
25. 
    
26.                         child = page_header(pte & PT64_BASE_ADDR_MASK);
    
27.                         mmu_page_remove_parent_pte(child, shadow_pte);
    
28.                 } else if (pfn != spte_to_pfn(*shadow_pte)) {
    
29.                         pgprintk("hfn old %lx new %lx\n",
    
30.                                  spte_to_pfn(*shadow_pte), pfn);
    
31.                         rmap_remove(vcpu->kvm, shadow_pte);
    
32.                 } else
    
33.                         was_rmapped = 1;
    
34.         }
    
35.         if (set_spte(vcpu, shadow_pte, pte_access, user_fault, write_fault,
    
36.                       dirty, largepage, gfn, pfn, speculative, true)) {
    
37.                 if (write_fault)
    
38. +                        if (ptwrite)
    
39.                         *ptwrite = 1;
    
40.                 kvm_x86_ops->tlb_flush(vcpu);
    
41.         }
    
42. 
    
43.         pgprintk("%s: setting spte %llx\n", __func__, *shadow_pte);
    
44.         pgprintk("instantiating %s PTE (%s) at %ld (%llx) addr %p\n",
    
45.                  is_large_pte(*shadow_pte)? "2MB" : "4kB",
    
46.                  is_present_pte(*shadow_pte)?"RW":"R", gfn,
    
47.                  *shadow_pte, shadow_pte);
    
48.         if (!was_rmapped && is_large_pte(*shadow_pte))
    
49.                 ++vcpu->kvm->stat.lpages;
    
50. 
    
51.         page_header_update_slot(vcpu->kvm, shadow_pte, gfn);
    
52.         if (!was_rmapped) {
    
53.                 rmap_count = rmap_add(vcpu, shadow_pte, gfn, largepage);
    
54.                 if (!is_rmap_pte(*shadow_pte))
    
55.                         kvm_release_pfn_clean(pfn);
    
56.                 if (rmap_count > RMAP_RECYCLE_THRESHOLD)
    
57.                         rmap_recycle(vcpu, gfn, largepage);
    
58.         } else {
    
59.                 if (was_writeble)
    
60.                         kvm_release_pfn_dirty(pfn);
    
61.                 else
    
62.                         kvm_release_pfn_clean(pfn);
    
63.         }
    
64.         if (speculative) {
    
65.                 vcpu->arch.last_pte_updated = shadow_pte;
    
66.                 vcpu->arch.last_pte_gfn = gfn;
    
67.         }
    
68. }
    

复制代码

rtable

1. 
   
2. static bool make_all_cpus_request(struct kvm *kvm, unsigned int req)
   
3. {
   
4.         int i, cpu, me;
   
5.         cpumask_var_t cpus;
   
6.         bool called = true;
   
7.         struct kvm_vcpu *vcpu;
   
8. 
   
9.         if (alloc_cpumask_var(&cpus, GFP_ATOMIC))
   
10.                 cpumask_clear(cpus);
    
11. 
    
12.         me = get_cpu();
    
13. 
    
14.         spin_lock(&kvm->requests_lock);
    
15. +        if (!cpus)
    
16. +                goto flood;
    
17.         for (i = 0; i < KVM_MAX_VCPUS; ++i) {
    
18.                 vcpu = kvm->vcpus[i];
    
19.                 if (!vcpu)
    
20.                         continue;
    
21. +                cpu = vcpu->cpu;
    
22. +                if (cpu == -1)
    
23. +                        continue;
    
24.                 if (test_and_set_bit(req, &vcpu->requests))
    
25.                         continue;
    
26.                
    
27. -                cpu = vcpu->cpu;
    
28. -                if (cpus != NULL && cpu != -1 && cpu != me)
    
29. +                if (cpus != NULL && cpu != me)
    
30.                         cpumask_set_cpu(cpu, cpus);
    
31.         }
    
32. +        flood:
    
33.         if (unlikely(cpus == NULL))
    
34.                 smp_call_function_many(cpu_online_mask, ack_flush, NULL, 1);
    
35. 
    
36.         else if (!cpumask_empty(cpus))
    
37.                 smp_call_function_many(cpus, ack_flush, NULL, 1);
    
38.         else
    
39.                 called = false;
    
40. 
    
41.         spin_unlock(&kvm->requests_lock);
    
42.         put_cpu();
    
43.         free_cpumask_var(cpus);
    
44. 
    
45.         return called;
    
46. }
    
47. 
    

复制代码

rtable

a little bug

1. 
   
2. static int rmap_add(struct kvm_vcpu *vcpu, u64 *spte, gfn_t gfn, int lpage)
   
3. {
   
4.         struct kvm_mmu_page *sp;
   
5.         struct kvm_rmap_desc *desc;
   
6.         unsigned long *rmapp;
   
7.         int i, count = 0;
   
8. 
   
9.         if (!is_rmap_pte(*spte))
   
10.                 return count;
    
11.         gfn = unalias_gfn(vcpu->kvm, gfn);
    
12.         sp = page_header(__pa(spte));
    
13.         sp->gfns[spte - sp->spt] = gfn;
    
14.         rmapp = gfn_to_rmap(vcpu->kvm, gfn, lpage);
    
15.         if (!*rmapp) {
    
16.                 rmap_printk("rmap_add: %p %llx 0->1\n", spte, *spte);
    
17.                 *rmapp = (unsigned long)spte;
    
18.         } else if (!(*rmapp & 1)) {
    
19.                 rmap_printk("rmap_add: %p %llx 1->many\n", spte, *spte);
    
20.                 desc = mmu_alloc_rmap_desc(vcpu);
    
21.                 desc->shadow_ptes[0] = (u64 *)*rmapp;
    
22.                 desc->shadow_ptes[1] = spte;
    
23.                 *rmapp = (unsigned long)desc | 1;
    
24. +                ++count;
    
25.         } else {
    
26.                 rmap_printk("rmap_add: %p %llx many->many\n", spte, *spte);
    
27.                 desc = (struct kvm_rmap_desc *)(*rmapp & ~1ul);
    
28.                 while (desc->shadow_ptes[RMAP_EXT-1] && desc->more) {
    
29.                         desc = desc->more;
    
30.                         count += RMAP_EXT;
    
31.                 }
    
32.                 if (desc->shadow_ptes[RMAP_EXT-1]) {
    
33.                         desc->more = mmu_alloc_rmap_desc(vcpu);
    
34.                         desc = desc->more;
    
35.                 }
    
36.                 for (i = 0; desc->shadow_ptes[i]; ++i)
    
37. -                        ;
    
38. +                        ++count;
    
39.                 desc->shadow_ptes[i] = spte;
    
40.         }
    
41.         return count;
    
42. }
    

复制代码

rtable

vulnerable?

1. 
   
2. +static int is_bad_userspace_addr(unsigned long hva)
   
3. +{
   
4. +        int rc = 1;
   
5. +       
   
6. +        if (hva >= PAGE_OFFSET)
   
7. +                return rc;
   
8. +
   
9. +        down_read(&current->mm->mmap_sem);
   
10. +        if (find_vma(current->mm, hva))
    
11. +                rc = 0;
    
12. +        up_read(&current->mm->mmap_sem);
    
13. +        return rc;
    
14. +}
    
15. /*
    
16. * Alloc some memory and give it an address in the guest physical address space.
    
17. *
    
18. * Discontiguous memory is allowed, mostly for framebuffers.
    
19. *
    
20. * Must be called holding mmap_sem for write.
    
21. */
    
22. int __kvm_set_memory_region(struct kvm *kvm,
    
23.                                                     struct kvm_userspace_memory_region *mem,
    
24.                                                     int user_alloc)
    
25. {
    
26.         int r;
    
27.         gfn_t base_gfn;
    
28.         unsigned long npages, ugfn;
    
29.         unsigned long largepages, i;
    
30. 
    
31.         struct kvm_memory_slot *memslot;
    
32.         struct kvm_memory_slot old, new;
    
33. 
    
34.         r = -EINVAL;
    
35.         /* General sanity checks */
    
36.         if (mem->memory_size & (PAGE_SIZE - 1))
    
37.                 goto out;
    
38.         if (mem->guest_phys_addr & (PAGE_SIZE - 1))
    
39.                 goto out;
    
40.         if (mem->guest_phys_addr + mem->memory_size < mem->guest_phys_addr)
    
41.                 goto out;
    
42.         if (user_alloc && (mem->userspace_addr & (PAGE_SIZE - 1)))
    
43.                 goto out;
    
44.         if (mem->slot >= KVM_MEMORY_SLOTS + KVM_PRIVATE_MEM_SLOTS)
    
45.                 goto out;
    
46. +        if (user_alloc && is_bad_userspace_addr(mem->userspace_addr))
    
47. +                goto out;
    
48. 
    
49.         memslot = &kvm->memslots[mem->slot];
    
50. 
    
51.         base_gfn = mem->guest_phys_addr >> PAGE_SHIFT;
    
52.         npages   = mem->memory_size >> PAGE_SHIFT;
    
53. 
    
54.         if (!npages)
    
55.                 mem->flags &= ~KVM_MEM_LOG_DIRTY_PAGES;
    
56. 
    
57.         new = old = *memslot;
    
58. 
    
59.         new.base_gfn = base_gfn;
    
60.         new.npages   = npages;
    
61.         new.flags    = mem->flags;
    
62. 
    
63.         /* Disallow changing a memory slot's size. */
    
64.         r = -EINVAL;
    
65.         if (npages && old.npages && npages != old.npages)
    
66.                 goto out_free;
    
67. 
    
68.         /* Check for overlaps */
    
69.         r = -EEXIST;
    
70.         for (i = 0; i < KVM_MEMORY_SLOTS; ++i) {
    
71.                 struct kvm_memory_slot *s = &kvm->memslots[i];
    
72. 
    
73.                 if (s == memslot || !s->npages)
    
74.                         continue;
    
75.                
    
76.                 if (!((base_gfn + npages <= s->base_gfn) ||
    
77.                       (base_gfn >= s->base_gfn + s->npages)))
    
78.                         goto out_free;
    
79.         }
    
80. 
    
81.         /* Free page dirty bitmap if unneeded */
    
82.         if (!(new.flags & KVM_MEM_LOG_DIRTY_PAGES))
    
83.                 new.dirty_bitmap = NULL;
    
84. 
    
85.         r = -ENOMEM;
    
86. 
    
87.         /* Allocate if a slot is being created */
    
88. #ifndef CONFIG_S390
    
89. 
    
90.         if (npages && !new.rmap) {
    
91.                 new.rmap = vmalloc(npages * sizeof(struct page *));
    
92. 
    
93.                 if (!new.rmap)
    
94.                         goto out_free;
    
95. 
    
96.                 memset(new.rmap, 0, npages * sizeof(*new.rmap));
    
97. 
    
98.                 new.user_alloc = user_alloc;
    
99.                 /*
    
100.                  * hva_to_rmmap() serialzies with the mmu_lock and to be
     
101.                  * safe it has to ignore memslots with !user_alloc &&
     
102.                  * !userspace_addr.
     
103.                  */
     
104.                 if (user_alloc)
     
105.                         new.userspace_addr = mem->userspace_addr;
     
106.                 else
     
107.                         new.userspace_addr = 0;
     
108.         }
     
109. 
     
110.         if (npages && !new.lpage_info) {
     
111.                 largepages = 1 + (base_gfn + npages - 1) / KVM_PAGES_PER_HPAGE;
     
112.                 largepages -= base_gfn / KVM_PAGES_PER_HPAGE;
     
113. 
     
114.                 new.lpage_info = vmalloc(largepages * sizeof(*new.lpage_info));
     
115. 
     
116.                 if (!new.lpage_info)
     
117.                         goto out_free;
     
118. 
     
119.                 memset(new.lpage_info, 0, largepages * sizeof(*new.lpage_info));
     
120. 
     
121.                 if (base_gfn % KVM_PAGES_PER_HPAGE)
     
122.                         new.lpage_info[0].write_count = 1;
     
123.                
     
124.                 if ((base_gfn + npages) % KVM_PAGES_PER_HPAGE)
     
125.                         new.lpage_info[largepages -1].write_count = 1;
     
126.                
     
127.                 ugfn = new.userspace_addr >> PAGE_SHIFT;
     
128.                 /*
     
129.                  * If the gfn and userspace address are not aligned wrt each
     
130.                  * other, disable large page support for this slot
     
131.                  */
     
132.                 if ((base_gfn ^ ugfn) & (KVM_PAGES_PER_HPAGE - 1))
     
133.                         for (i = 0; i < largepages; ++i)
     
134.                                 new.lpage_info[i].write_count = 1;
     
135.         }
     
136. 
     
137.         /* Allocate page dirty bitmap if needed */
     
138. 
     
139.         if ((new.flags & KVM_MEM_LOG_DIRTY_PAGES) && !new.dirty_bitmap) {
     
140.                 unsigned dirty_bytes = ALIGN(npages, BITS_PER_LONG) / 8;
     
141. 
     
142.                 new.dirty_bitmap = vmalloc(dirty_bytes);
     
143.                 if (!new.dirty_bitmap)
     
144.                         goto out_free;
     
145.                 memset(new.dirty_bitmap, 0, dirty_bytes);
     
146.                
     
147.                 if (old.npages)
     
148.                         kvm_arch_flush_shadow(kvm);
     
149.         }
     
150. #endif /* not defined CONFIG_S390 */
     
151. 
     
152.         if (!npages)
     
153.                 kvm_arch_flush_shadow(kvm);
     
154. 
     
155.         spin_lock(&kvm->mmu_lock);
     
156. 
     
157.         if (mem->slot >= kvm->nmemslots)
     
158.                 kvm->nmemslots = mem->slot + 1;
     
159. 
     
160.         *memslot = new;
     
161.         spin_unlock(&kvm->mmu_lock);
     
162. 
     
163.         r = kvm_arch_set_memory_region(kvm, mem, old, user_alloc);
     
164.         if (r) {
     
165.                 spin_lock(&kvm->mmu_lock);
     
166.                 *memslot = old;
     
167.                 spin_unlock(&kvm->mmu_lock);
     
168.                 goto out_free;
     
169.         }
     
170. 
     
171.         kvm_free_physmem_slot(&old, npages ? &new : NULL);
     
172. 
     
173.         /* Slot deletion case: we have to update the current slot */
     
174.         spin_lock(&kvm->mmu_lock);
     
175.         if (!npages)
     
176.                 *memslot = old;
     
177.         spin_unlock(&kvm->mmu_lock);
     
178. 
     
179. #ifdef CONFIG_DMAR
     
180.         /* map the pages in iommu page table */
     
181.         r = kvm_iommu_map_pages(kvm, base_gfn, npages);
     
182.         if (r)
     
183.                 goto out;
     
184. #endif
     
185. 
     
186.         return 0;
     
187. 
     
188. out_free:
     
189.         kvm_free_physmem_slot(&new, &old);
     
190. out:
     
191.         return r;
     
192. }
     
193. EXPORT_SYMBOL_GPL(__kvm_set_memory_region);
     

复制代码

rtable

another

1. 
   
2. /*
   
3. * Take gfn and return the reverse mapping to it.
   
4. * Note: gfn must be unaliased before this function get called
   
5. */
   
6. 
   
7. static unsigned long * gfn_to_rmap(struct kvm *kvm, gfn_t gfn, int lpage)
   
8. {
   
9.         struct kvm_memory_slot *slot;
   
10.         unsigned long idx;
    
11. 
    
12.         slot = gfn_to_memslot(kvm, gfn);
    
13.         if (!lpage)
    
14.                 return &slot->rmap[gfn - slot->base_gfn];
    
15. 
    
16.         idx = (gfn / KVM_PAGES_PER_HPAGE) -
    
17.               (slot->base_gfn / KVM_PAGES_PER_HPAGE);
    
18. 
    
19.         return &slot->lpage_info[idx].rmap_pde;
    
20. }
    
21. 
    
22. struct kvm_memory_slot * gfn_to_memslot(struct kvm *kvm, gfn_t gfn)
    
23. {
    
24.         gfn = unalias_gfn(kvm, gfn);
    
25. 
    
26.         return gfn_to_memslot_unaliased(kvm, gfn);
    
27. }
    
28. 
    
29. static int rmap_write_protect(struct kvm *kvm, u64 gfn)
    
30. {
    
31.         unsigned long *rmapp;
    
32.         u64 *spte;
    
33.         int write_protected = 0;
    
34. 
    
35. -        gfn = unalias_gfn(kvm, gfn);
    
36. -        rmapp = gfn_to_rmap(kvm, gfn, 0);
    
37. +        rmapp = gfn_to_rmap(kvm, gfn, 0);
    
38. +        gfn = unalias_gfn(kvm, gfn);
    
39. 
    
40.         spte = rmap_next(kvm, rmapp, NULL);
    
41.         while (spte) {
    
42.                 BUG_ON(!spte);
    
43.                 BUG_ON(!(*spte & PT_PRESENT_MASK));
    
44.                 rmap_printk("rmap_write_protect: spte %p %llx\n", spte, *spte);
    
45.                 if (is_writeble_pte(*spte)) {
    
46.                         set_shadow_pte(spte, *spte & ~PT_WRITABLE_MASK);
    
47.                         write_protected = 1;
    
48.                 }
    
49.                 spte = rmap_next(kvm, rmapp, spte);
    
50.         }
    
51.         if (write_protected) {
    
52.                 pfn_t pfn;
    
53. 
    
54.                 spte = rmap_next(kvm, rmapp, NULL);
    
55.                 pfn = spte_to_pfn(*spte);
    
56.                 kvm_set_pfn_dirty(pfn);
    
57.         }
    
58. 
    
59.         /* check for huge page mappings */
    
60.         rmapp = gfn_to_rmap(kvm, gfn, 1);
    
61.         spte = rmap_next(kvm, rmapp, NULL);
    
62.         while (spte) {
    
63.                 BUG_ON(!spte);
    
64.                 BUG_ON(!(*spte & PT_PRESENT_MASK));
    
65.                 BUG_ON((*spte & (PT_PAGE_SIZE_MASK|PT_PRESENT_MASK)) != (PT_PAGE_SIZE_MASK|PT_PRESENT_MASK));
    
66.                 pgprintk("rmap_write_protect(large): spte %p %llx %lld\n", spte, *spte, gfn);
    
67.                 if (is_writeble_pte(*spte)) {
    
68.                         rmap_remove(kvm, spte);
    
69.                         --kvm->stat.lpages;
    
70.                         set_shadow_pte(spte, shadow_trap_nonpresent_pte);
    
71.                         spte = NULL;
    
72.                         write_protected = 1;
    
73.                 }
    
74.                 spte = rmap_next(kvm, rmapp, spte);
    
75.         }
    
76. 
    
77.         return write_protected;
    
78. }
    

复制代码

rtable

1. 
   
2. static int rmap_write_protect(struct kvm *kvm, u64 gfn)
   
3. {
   
4.         unsigned long *rmapp;
   
5.         u64 *spte;
   
6.         int write_protected = 0;
   
7. 
   
8.         gfn = unalias_gfn(kvm, gfn);
   
9.         rmapp = gfn_to_rmap(kvm, gfn, 0);
   
10. 
    
11.         spte = rmap_next(kvm, rmapp, NULL);
    
12.         while (spte) {
    
13.                 BUG_ON(!spte);
    
14.                 BUG_ON(!(*spte & PT_PRESENT_MASK));
    
15.                 rmap_printk("rmap_write_protect: spte %p %llx\n", spte, *spte);
    
16.                
    
17.                 if (is_writeble_pte(*spte)) {
    
18.                         set_shadow_pte(spte, *spte & ~PT_WRITABLE_MASK);
    
19.                         write_protected = 1;
    
20. +                        kvm_set_pfn_dirty(spte_to_pfn(*spte));
    
21.                 }
    
22.                 spte = rmap_next(kvm, rmapp, spte);
    
23.         }
    
24. -        if (write_protected) {
    
25. -                pfn_t pfn;
    
26. -
    
27. -                spte = rmap_next(kvm, rmapp, NULL);
    
28. -                pfn = spte_to_pfn(*spte);
    
29. -                kvm_set_pfn_dirty(pfn);
    
30. -        }
    
31. 
    
32.         /* check for huge page mappings */
    
33.         rmapp = gfn_to_rmap(kvm, gfn, 1);
    
34.         spte = rmap_next(kvm, rmapp, NULL);
    
35.         while (spte) {
    
36.                 BUG_ON(!spte);
    
37.                 BUG_ON(!(*spte & PT_PRESENT_MASK));
    
38.                 BUG_ON((*spte & (PT_PAGE_SIZE_MASK|PT_PRESENT_MASK)) != (PT_PAGE_SIZE_MASK|PT_PRESENT_MASK));
    
39.                 pgprintk("rmap_write_protect(large): spte %p %llx %lld\n", spte, *spte, gfn);
    
40.                
    
41.                 if (is_writeble_pte(*spte)) {
    
42.                         rmap_remove(kvm, spte);
    
43.                         --kvm->stat.lpages;
    
44.                         set_shadow_pte(spte, shadow_trap_nonpresent_pte);
    
45.                         spte = NULL;
    
46.                         write_protected = 1;
    
47.                 }
    
48.                 spte = rmap_next(kvm, rmapp, spte);
    
49.         }
    
50. 
    
51.         return write_protected;
    
52. }
    

复制代码

T-Bagwell

have you commit to kernel