ia64: remove some warnings.
[sfrench/cifs-2.6.git] / arch / ia64 / kvm / vtlb.c
1 /*
2  * vtlb.c: guest virtual tlb handling module.
3  * Copyright (c) 2004, Intel Corporation.
4  *  Yaozu Dong (Eddie Dong) <Eddie.dong@intel.com>
5  *  Xuefei Xu (Anthony Xu) <anthony.xu@intel.com>
6  *
7  * Copyright (c) 2007, Intel Corporation.
8  *  Xuefei Xu (Anthony Xu) <anthony.xu@intel.com>
9  *  Xiantao Zhang <xiantao.zhang@intel.com>
10  *
11  * This program is free software; you can redistribute it and/or modify it
12  * under the terms and conditions of the GNU General Public License,
13  * version 2, as published by the Free Software Foundation.
14  *
15  * This program is distributed in the hope it will be useful, but WITHOUT
16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
18  * more details.
19  *
20  * You should have received a copy of the GNU General Public License along with
21  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
22  * Place - Suite 330, Boston, MA 02111-1307 USA.
23  *
24  */
25
26 #include "vcpu.h"
27
28 #include <linux/rwsem.h>
29
30 #include <asm/tlb.h>
31
32 /*
33  * Check to see if the address rid:va is translated by the TLB
34  */
35
36 static int __is_tr_translated(struct thash_data *trp, u64 rid, u64 va)
37 {
38         return ((trp->p) && (trp->rid == rid)
39                                 && ((va-trp->vadr) < PSIZE(trp->ps)));
40 }
41
42 /*
43  * Only for GUEST TR format.
44  */
45 static int __is_tr_overlap(struct thash_data *trp, u64 rid, u64 sva, u64 eva)
46 {
47         u64 sa1, ea1;
48
49         if (!trp->p || trp->rid != rid)
50                 return 0;
51
52         sa1 = trp->vadr;
53         ea1 = sa1 + PSIZE(trp->ps) - 1;
54         eva -= 1;
55         if ((sva > ea1) || (sa1 > eva))
56                 return 0;
57         else
58                 return 1;
59
60 }
61
62 void machine_tlb_purge(u64 va, u64 ps)
63 {
64         ia64_ptcl(va, ps << 2);
65 }
66
67 void local_flush_tlb_all(void)
68 {
69         int i, j;
70         unsigned long flags, count0, count1;
71         unsigned long stride0, stride1, addr;
72
73         addr    = current_vcpu->arch.ptce_base;
74         count0  = current_vcpu->arch.ptce_count[0];
75         count1  = current_vcpu->arch.ptce_count[1];
76         stride0 = current_vcpu->arch.ptce_stride[0];
77         stride1 = current_vcpu->arch.ptce_stride[1];
78
79         local_irq_save(flags);
80         for (i = 0; i < count0; ++i) {
81                 for (j = 0; j < count1; ++j) {
82                         ia64_ptce(addr);
83                         addr += stride1;
84                 }
85                 addr += stride0;
86         }
87         local_irq_restore(flags);
88         ia64_srlz_i();          /* srlz.i implies srlz.d */
89 }
90
91 int vhpt_enabled(struct kvm_vcpu *vcpu, u64 vadr, enum vhpt_ref ref)
92 {
93         union ia64_rr    vrr;
94         union ia64_pta   vpta;
95         struct  ia64_psr   vpsr;
96
97         vpsr = *(struct ia64_psr *)&VCPU(vcpu, vpsr);
98         vrr.val = vcpu_get_rr(vcpu, vadr);
99         vpta.val = vcpu_get_pta(vcpu);
100
101         if (vrr.ve & vpta.ve) {
102                 switch (ref) {
103                 case DATA_REF:
104                 case NA_REF:
105                         return vpsr.dt;
106                 case INST_REF:
107                         return vpsr.dt && vpsr.it && vpsr.ic;
108                 case RSE_REF:
109                         return vpsr.dt && vpsr.rt;
110
111                 }
112         }
113         return 0;
114 }
115
116 struct thash_data *vsa_thash(union ia64_pta vpta, u64 va, u64 vrr, u64 *tag)
117 {
118         u64 index, pfn, rid, pfn_bits;
119
120         pfn_bits = vpta.size - 5 - 8;
121         pfn = REGION_OFFSET(va) >> _REGION_PAGE_SIZE(vrr);
122         rid = _REGION_ID(vrr);
123         index = ((rid & 0xff) << pfn_bits)|(pfn & ((1UL << pfn_bits) - 1));
124         *tag = ((rid >> 8) & 0xffff) | ((pfn >> pfn_bits) << 16);
125
126         return (struct thash_data *)((vpta.base << PTA_BASE_SHIFT) +
127                                 (index << 5));
128 }
129
130 struct thash_data *__vtr_lookup(struct kvm_vcpu *vcpu, u64 va, int type)
131 {
132
133         struct thash_data *trp;
134         int  i;
135         u64 rid;
136
137         rid = vcpu_get_rr(vcpu, va);
138         rid = rid & RR_RID_MASK;;
139         if (type == D_TLB) {
140                 if (vcpu_quick_region_check(vcpu->arch.dtr_regions, va)) {
141                         for (trp = (struct thash_data *)&vcpu->arch.dtrs, i = 0;
142                                                 i < NDTRS; i++, trp++) {
143                                 if (__is_tr_translated(trp, rid, va))
144                                         return trp;
145                         }
146                 }
147         } else {
148                 if (vcpu_quick_region_check(vcpu->arch.itr_regions, va)) {
149                         for (trp = (struct thash_data *)&vcpu->arch.itrs, i = 0;
150                                         i < NITRS; i++, trp++) {
151                                 if (__is_tr_translated(trp, rid, va))
152                                         return trp;
153                         }
154                 }
155         }
156
157         return NULL;
158 }
159
160 static void vhpt_insert(u64 pte, u64 itir, u64 ifa, u64 gpte)
161 {
162         union ia64_rr rr;
163         struct thash_data *head;
164         unsigned long ps, gpaddr;
165
166         ps = itir_ps(itir);
167
168         gpaddr = ((gpte & _PAGE_PPN_MASK) >> ps << ps) |
169                 (ifa & ((1UL << ps) - 1));
170
171         rr.val = ia64_get_rr(ifa);
172         head = (struct thash_data *)ia64_thash(ifa);
173         head->etag = INVALID_TI_TAG;
174         ia64_mf();
175         head->page_flags = pte & ~PAGE_FLAGS_RV_MASK;
176         head->itir = rr.ps << 2;
177         head->etag = ia64_ttag(ifa);
178         head->gpaddr = gpaddr;
179 }
180
181 void mark_pages_dirty(struct kvm_vcpu *v, u64 pte, u64 ps)
182 {
183         u64 i, dirty_pages = 1;
184         u64 base_gfn = (pte&_PAGE_PPN_MASK) >> PAGE_SHIFT;
185         spinlock_t *lock = __kvm_va(v->arch.dirty_log_lock_pa);
186         void *dirty_bitmap = (void *)KVM_MEM_DIRTY_LOG_BASE;
187
188         dirty_pages <<= ps <= PAGE_SHIFT ? 0 : ps - PAGE_SHIFT;
189
190         vmm_spin_lock(lock);
191         for (i = 0; i < dirty_pages; i++) {
192                 /* avoid RMW */
193                 if (!test_bit(base_gfn + i, dirty_bitmap))
194                         set_bit(base_gfn + i , dirty_bitmap);
195         }
196         vmm_spin_unlock(lock);
197 }
198
199 void thash_vhpt_insert(struct kvm_vcpu *v, u64 pte, u64 itir, u64 va, int type)
200 {
201         u64 phy_pte, psr;
202         union ia64_rr mrr;
203
204         mrr.val = ia64_get_rr(va);
205         phy_pte = translate_phy_pte(&pte, itir, va);
206
207         if (itir_ps(itir) >= mrr.ps) {
208                 vhpt_insert(phy_pte, itir, va, pte);
209         } else {
210                 phy_pte  &= ~PAGE_FLAGS_RV_MASK;
211                 psr = ia64_clear_ic();
212                 ia64_itc(type, va, phy_pte, itir_ps(itir));
213                 paravirt_dv_serialize_data();
214                 ia64_set_psr(psr);
215         }
216
217         if (!(pte&VTLB_PTE_IO))
218                 mark_pages_dirty(v, pte, itir_ps(itir));
219 }
220
221 /*
222  *   vhpt lookup
223  */
224 struct thash_data *vhpt_lookup(u64 va)
225 {
226         struct thash_data *head;
227         u64 tag;
228
229         head = (struct thash_data *)ia64_thash(va);
230         tag = ia64_ttag(va);
231         if (head->etag == tag)
232                 return head;
233         return NULL;
234 }
235
236 u64 guest_vhpt_lookup(u64 iha, u64 *pte)
237 {
238         u64 ret;
239         struct thash_data *data;
240
241         data = __vtr_lookup(current_vcpu, iha, D_TLB);
242         if (data != NULL)
243                 thash_vhpt_insert(current_vcpu, data->page_flags,
244                         data->itir, iha, D_TLB);
245
246         asm volatile ("rsm psr.ic|psr.i;;"
247                         "srlz.d;;"
248                         "ld8.s r9=[%1];;"
249                         "tnat.nz p6,p7=r9;;"
250                         "(p6) mov %0=1;"
251                         "(p6) mov r9=r0;"
252                         "(p7) extr.u r9=r9,0,53;;"
253                         "(p7) mov %0=r0;"
254                         "(p7) st8 [%2]=r9;;"
255                         "ssm psr.ic;;"
256                         "srlz.d;;"
257                         /* "ssm psr.i;;" Once interrupts in vmm open, need fix*/
258                         : "=r"(ret) : "r"(iha), "r"(pte):"memory");
259
260         return ret;
261 }
262
263 /*
264  *  purge software guest tlb
265  */
266
267 static void vtlb_purge(struct kvm_vcpu *v, u64 va, u64 ps)
268 {
269         struct thash_data *cur;
270         u64 start, curadr, size, psbits, tag, rr_ps, num;
271         union ia64_rr vrr;
272         struct thash_cb *hcb = &v->arch.vtlb;
273
274         vrr.val = vcpu_get_rr(v, va);
275         psbits = VMX(v, psbits[(va >> 61)]);
276         start = va & ~((1UL << ps) - 1);
277         while (psbits) {
278                 curadr = start;
279                 rr_ps = __ffs(psbits);
280                 psbits &= ~(1UL << rr_ps);
281                 num = 1UL << ((ps < rr_ps) ? 0 : (ps - rr_ps));
282                 size = PSIZE(rr_ps);
283                 vrr.ps = rr_ps;
284                 while (num) {
285                         cur = vsa_thash(hcb->pta, curadr, vrr.val, &tag);
286                         if (cur->etag == tag && cur->ps == rr_ps)
287                                 cur->etag = INVALID_TI_TAG;
288                         curadr += size;
289                         num--;
290                 }
291         }
292 }
293
294
295 /*
296  *  purge VHPT and machine TLB
297  */
298 static void vhpt_purge(struct kvm_vcpu *v, u64 va, u64 ps)
299 {
300         struct thash_data *cur;
301         u64 start, size, tag, num;
302         union ia64_rr rr;
303
304         start = va & ~((1UL << ps) - 1);
305         rr.val = ia64_get_rr(va);
306         size = PSIZE(rr.ps);
307         num = 1UL << ((ps < rr.ps) ? 0 : (ps - rr.ps));
308         while (num) {
309                 cur = (struct thash_data *)ia64_thash(start);
310                 tag = ia64_ttag(start);
311                 if (cur->etag == tag)
312                         cur->etag = INVALID_TI_TAG;
313                 start += size;
314                 num--;
315         }
316         machine_tlb_purge(va, ps);
317 }
318
319 /*
320  * Insert an entry into hash TLB or VHPT.
321  * NOTES:
322  *  1: When inserting VHPT to thash, "va" is a must covered
323  *  address by the inserted machine VHPT entry.
324  *  2: The format of entry is always in TLB.
325  *  3: The caller need to make sure the new entry will not overlap
326  *     with any existed entry.
327  */
328 void vtlb_insert(struct kvm_vcpu *v, u64 pte, u64 itir, u64 va)
329 {
330         struct thash_data *head;
331         union ia64_rr vrr;
332         u64 tag;
333         struct thash_cb *hcb = &v->arch.vtlb;
334
335         vrr.val = vcpu_get_rr(v, va);
336         vrr.ps = itir_ps(itir);
337         VMX(v, psbits[va >> 61]) |= (1UL << vrr.ps);
338         head = vsa_thash(hcb->pta, va, vrr.val, &tag);
339         head->page_flags = pte;
340         head->itir = itir;
341         head->etag = tag;
342 }
343
344 int vtr_find_overlap(struct kvm_vcpu *vcpu, u64 va, u64 ps, int type)
345 {
346         struct thash_data  *trp;
347         int  i;
348         u64 end, rid;
349
350         rid = vcpu_get_rr(vcpu, va);
351         rid = rid & RR_RID_MASK;
352         end = va + PSIZE(ps);
353         if (type == D_TLB) {
354                 if (vcpu_quick_region_check(vcpu->arch.dtr_regions, va)) {
355                         for (trp = (struct thash_data *)&vcpu->arch.dtrs, i = 0;
356                                         i < NDTRS; i++, trp++) {
357                                 if (__is_tr_overlap(trp, rid, va, end))
358                                         return i;
359                         }
360                 }
361         } else {
362                 if (vcpu_quick_region_check(vcpu->arch.itr_regions, va)) {
363                         for (trp = (struct thash_data *)&vcpu->arch.itrs, i = 0;
364                                         i < NITRS; i++, trp++) {
365                                 if (__is_tr_overlap(trp, rid, va, end))
366                                         return i;
367                         }
368                 }
369         }
370         return -1;
371 }
372
373 /*
374  * Purge entries in VTLB and VHPT
375  */
376 void thash_purge_entries(struct kvm_vcpu *v, u64 va, u64 ps)
377 {
378         if (vcpu_quick_region_check(v->arch.tc_regions, va))
379                 vtlb_purge(v, va, ps);
380         vhpt_purge(v, va, ps);
381 }
382
383 void thash_purge_entries_remote(struct kvm_vcpu *v, u64 va, u64 ps)
384 {
385         u64 old_va = va;
386         va = REGION_OFFSET(va);
387         if (vcpu_quick_region_check(v->arch.tc_regions, old_va))
388                 vtlb_purge(v, va, ps);
389         vhpt_purge(v, va, ps);
390 }
391
392 u64 translate_phy_pte(u64 *pte, u64 itir, u64 va)
393 {
394         u64 ps, ps_mask, paddr, maddr, io_mask;
395         union pte_flags phy_pte;
396
397         ps = itir_ps(itir);
398         ps_mask = ~((1UL << ps) - 1);
399         phy_pte.val = *pte;
400         paddr = *pte;
401         paddr = ((paddr & _PAGE_PPN_MASK) & ps_mask) | (va & ~ps_mask);
402         maddr = kvm_get_mpt_entry(paddr >> PAGE_SHIFT);
403         io_mask = maddr & GPFN_IO_MASK;
404         if (io_mask && (io_mask != GPFN_PHYS_MMIO)) {
405                 *pte |= VTLB_PTE_IO;
406                 return -1;
407         }
408         maddr = ((maddr & _PAGE_PPN_MASK) & PAGE_MASK) |
409                                         (paddr & ~PAGE_MASK);
410         phy_pte.ppn = maddr >> ARCH_PAGE_SHIFT;
411         return phy_pte.val;
412 }
413
414 /*
415  * Purge overlap TCs and then insert the new entry to emulate itc ops.
416  *    Notes: Only TC entry can purge and insert.
417  *    1 indicates this is MMIO
418  */
419 int thash_purge_and_insert(struct kvm_vcpu *v, u64 pte, u64 itir,
420                                                 u64 ifa, int type)
421 {
422         u64 ps;
423         u64 phy_pte, io_mask, index;
424         union ia64_rr vrr, mrr;
425         int ret = 0;
426
427         ps = itir_ps(itir);
428         vrr.val = vcpu_get_rr(v, ifa);
429         mrr.val = ia64_get_rr(ifa);
430
431         index = (pte & _PAGE_PPN_MASK) >> PAGE_SHIFT;
432         io_mask = kvm_get_mpt_entry(index) & GPFN_IO_MASK;
433         phy_pte = translate_phy_pte(&pte, itir, ifa);
434
435         /* Ensure WB attribute if pte is related to a normal mem page,
436          * which is required by vga acceleration since qemu maps shared
437          * vram buffer with WB.
438          */
439         if (!(pte & VTLB_PTE_IO) && ((pte & _PAGE_MA_MASK) != _PAGE_MA_NAT) &&
440                         io_mask != GPFN_PHYS_MMIO) {
441                 pte &= ~_PAGE_MA_MASK;
442                 phy_pte &= ~_PAGE_MA_MASK;
443         }
444
445         if (pte & VTLB_PTE_IO)
446                 ret = 1;
447
448         vtlb_purge(v, ifa, ps);
449         vhpt_purge(v, ifa, ps);
450
451         if (ps == mrr.ps) {
452                 if (!(pte&VTLB_PTE_IO)) {
453                         vhpt_insert(phy_pte, itir, ifa, pte);
454                 } else {
455                         vtlb_insert(v, pte, itir, ifa);
456                         vcpu_quick_region_set(VMX(v, tc_regions), ifa);
457                 }
458         } else if (ps > mrr.ps) {
459                 vtlb_insert(v, pte, itir, ifa);
460                 vcpu_quick_region_set(VMX(v, tc_regions), ifa);
461                 if (!(pte&VTLB_PTE_IO))
462                         vhpt_insert(phy_pte, itir, ifa, pte);
463         } else {
464                 u64 psr;
465                 phy_pte  &= ~PAGE_FLAGS_RV_MASK;
466                 psr = ia64_clear_ic();
467                 ia64_itc(type, ifa, phy_pte, ps);
468                 paravirt_dv_serialize_data();
469                 ia64_set_psr(psr);
470         }
471         if (!(pte&VTLB_PTE_IO))
472                 mark_pages_dirty(v, pte, ps);
473
474         return ret;
475 }
476
477 /*
478  * Purge all TCs or VHPT entries including those in Hash table.
479  *
480  */
481
482 void thash_purge_all(struct kvm_vcpu *v)
483 {
484         int i;
485         struct thash_data *head;
486         struct thash_cb  *vtlb, *vhpt;
487         vtlb = &v->arch.vtlb;
488         vhpt = &v->arch.vhpt;
489
490         for (i = 0; i < 8; i++)
491                 VMX(v, psbits[i]) = 0;
492
493         head = vtlb->hash;
494         for (i = 0; i < vtlb->num; i++) {
495                 head->page_flags = 0;
496                 head->etag = INVALID_TI_TAG;
497                 head->itir = 0;
498                 head->next = 0;
499                 head++;
500         };
501
502         head = vhpt->hash;
503         for (i = 0; i < vhpt->num; i++) {
504                 head->page_flags = 0;
505                 head->etag = INVALID_TI_TAG;
506                 head->itir = 0;
507                 head->next = 0;
508                 head++;
509         };
510
511         local_flush_tlb_all();
512 }
513
514
515 /*
516  * Lookup the hash table and its collision chain to find an entry
517  * covering this address rid:va or the entry.
518  *
519  * INPUT:
520  *  in: TLB format for both VHPT & TLB.
521  */
522
523 struct thash_data *vtlb_lookup(struct kvm_vcpu *v, u64 va, int is_data)
524 {
525         struct thash_data  *cch;
526         u64    psbits, ps, tag;
527         union ia64_rr vrr;
528
529         struct thash_cb *hcb = &v->arch.vtlb;
530
531         cch = __vtr_lookup(v, va, is_data);;
532         if (cch)
533                 return cch;
534
535         if (vcpu_quick_region_check(v->arch.tc_regions, va) == 0)
536                 return NULL;
537
538         psbits = VMX(v, psbits[(va >> 61)]);
539         vrr.val = vcpu_get_rr(v, va);
540         while (psbits) {
541                 ps = __ffs(psbits);
542                 psbits &= ~(1UL << ps);
543                 vrr.ps = ps;
544                 cch = vsa_thash(hcb->pta, va, vrr.val, &tag);
545                 if (cch->etag == tag && cch->ps == ps)
546                         return cch;
547         }
548
549         return NULL;
550 }
551
552
553 /*
554  * Initialize internal control data before service.
555  */
556 void thash_init(struct thash_cb *hcb, u64 sz)
557 {
558         int i;
559         struct thash_data *head;
560
561         hcb->pta.val = (unsigned long)hcb->hash;
562         hcb->pta.vf = 1;
563         hcb->pta.ve = 1;
564         hcb->pta.size = sz;
565         head = hcb->hash;
566         for (i = 0; i < hcb->num; i++) {
567                 head->page_flags = 0;
568                 head->itir = 0;
569                 head->etag = INVALID_TI_TAG;
570                 head->next = 0;
571                 head++;
572         }
573 }
574
575 u64 kvm_get_mpt_entry(u64 gpfn)
576 {
577         u64 *base = (u64 *) KVM_P2M_BASE;
578         return *(base + gpfn);
579 }
580
581 u64 kvm_lookup_mpa(u64 gpfn)
582 {
583         u64 maddr;
584         maddr = kvm_get_mpt_entry(gpfn);
585         return maddr&_PAGE_PPN_MASK;
586 }
587
588 u64 kvm_gpa_to_mpa(u64 gpa)
589 {
590         u64 pte = kvm_lookup_mpa(gpa >> PAGE_SHIFT);
591         return (pte >> PAGE_SHIFT << PAGE_SHIFT) | (gpa & ~PAGE_MASK);
592 }
593
594
595 /*
596  * Fetch guest bundle code.
597  * INPUT:
598  *  gip: guest ip
599  *  pbundle: used to return fetched bundle.
600  */
601 int fetch_code(struct kvm_vcpu *vcpu, u64 gip, IA64_BUNDLE *pbundle)
602 {
603         u64     gpip = 0;   /* guest physical IP*/
604         u64     *vpa;
605         struct thash_data    *tlb;
606         u64     maddr;
607
608         if (!(VCPU(vcpu, vpsr) & IA64_PSR_IT)) {
609                 /* I-side physical mode */
610                 gpip = gip;
611         } else {
612                 tlb = vtlb_lookup(vcpu, gip, I_TLB);
613                 if (tlb)
614                         gpip = (tlb->ppn >> (tlb->ps - 12) << tlb->ps) |
615                                 (gip & (PSIZE(tlb->ps) - 1));
616         }
617         if (gpip) {
618                 maddr = kvm_gpa_to_mpa(gpip);
619         } else {
620                 tlb = vhpt_lookup(gip);
621                 if (tlb == NULL) {
622                         ia64_ptcl(gip, ARCH_PAGE_SHIFT << 2);
623                         return IA64_FAULT;
624                 }
625                 maddr = (tlb->ppn >> (tlb->ps - 12) << tlb->ps)
626                                         | (gip & (PSIZE(tlb->ps) - 1));
627         }
628         vpa = (u64 *)__kvm_va(maddr);
629
630         pbundle->i64[0] = *vpa++;
631         pbundle->i64[1] = *vpa;
632
633         return IA64_NO_FAULT;
634 }
635
636
637 void kvm_init_vhpt(struct kvm_vcpu *v)
638 {
639         v->arch.vhpt.num = VHPT_NUM_ENTRIES;
640         thash_init(&v->arch.vhpt, VHPT_SHIFT);
641         ia64_set_pta(v->arch.vhpt.pta.val);
642         /*Enable VHPT here?*/
643 }
644
645 void kvm_init_vtlb(struct kvm_vcpu *v)
646 {
647         v->arch.vtlb.num = VTLB_NUM_ENTRIES;
648         thash_init(&v->arch.vtlb, VTLB_SHIFT);
649 }