Rev 3228 | Rev 3393 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
| Rev 3228 | Rev 3392 | ||
|---|---|---|---|
| Line 45... | Line 45... | ||
| 45 | #include <print.h> |
45 | #include <print.h> |
| 46 | #include <debug.h> |
46 | #include <debug.h> |
| 47 | #include <align.h> |
47 | #include <align.h> |
| 48 | #include <interrupt.h> |
48 | #include <interrupt.h> |
| 49 | 49 | ||
| 50 | static void tlb_refill_fail(istate_t *istate); |
50 | static void tlb_refill_fail(istate_t *); |
| 51 | static void tlb_invalid_fail(istate_t *istate); |
51 | static void tlb_invalid_fail(istate_t *); |
| 52 | static void tlb_modified_fail(istate_t *istate); |
52 | static void tlb_modified_fail(istate_t *); |
| 53 | 53 | ||
| 54 | static pte_t *find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate, int *pfrc); |
54 | static pte_t *find_mapping_and_check(uintptr_t, int, istate_t *, int *); |
| 55 | 55 | ||
| 56 | /** Initialize TLB |
56 | /** Initialize TLB. |
| 57 | * |
57 | * |
| 58 | * Initialize TLB. |
- | |
| 59 | * Invalidate all entries and mark wired entries. |
58 | * Invalidate all entries and mark wired entries. |
| 60 | */ |
59 | */ |
| 61 | void tlb_arch_init(void) |
60 | void tlb_arch_init(void) |
| 62 | { |
61 | { |
| 63 | int i; |
62 | int i; |
| Line 79... | Line 78... | ||
| 79 | * entries (e.g. mapping kernel stacks in kseg3). |
78 | * entries (e.g. mapping kernel stacks in kseg3). |
| 80 | */ |
79 | */ |
| 81 | cp0_wired_write(TLB_WIRED); |
80 | cp0_wired_write(TLB_WIRED); |
| 82 | } |
81 | } |
| 83 | 82 | ||
| 84 | /** Process TLB Refill Exception |
83 | /** Process TLB Refill Exception. |
| 85 | * |
84 | * |
| 86 | * Process TLB Refill Exception. |
- | |
| 87 | * |
- | |
| 88 | * @param istate Interrupted register context. |
85 | * @param istate Interrupted register context. |
| 89 | */ |
86 | */ |
| 90 | void tlb_refill(istate_t *istate) |
87 | void tlb_refill(istate_t *istate) |
| 91 | { |
88 | { |
| 92 | entry_lo_t lo; |
89 | entry_lo_t lo; |
| 93 | entry_hi_t hi; |
90 | entry_hi_t hi; |
| Line 126... | Line 123... | ||
| 126 | * Record access to PTE. |
123 | * Record access to PTE. |
| 127 | */ |
124 | */ |
| 128 | pte->a = 1; |
125 | pte->a = 1; |
| 129 | 126 | ||
| 130 | tlb_prepare_entry_hi(&hi, asid, badvaddr); |
127 | tlb_prepare_entry_hi(&hi, asid, badvaddr); |
| 131 | tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, pte->pfn); |
128 | tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, |
| - | 129 | pte->pfn); |
|
| 132 | 130 | ||
| 133 | /* |
131 | /* |
| 134 | * New entry is to be inserted into TLB |
132 | * New entry is to be inserted into TLB |
| 135 | */ |
133 | */ |
| 136 | cp0_entry_hi_write(hi.value); |
134 | cp0_entry_hi_write(hi.value); |
| 137 | if ((badvaddr/PAGE_SIZE) % 2 == 0) { |
135 | if ((badvaddr / PAGE_SIZE) % 2 == 0) { |
| 138 | cp0_entry_lo0_write(lo.value); |
136 | cp0_entry_lo0_write(lo.value); |
| 139 | cp0_entry_lo1_write(0); |
137 | cp0_entry_lo1_write(0); |
| 140 | } |
138 | } |
| 141 | else { |
139 | else { |
| 142 | cp0_entry_lo0_write(0); |
140 | cp0_entry_lo0_write(0); |
| Line 151... | Line 149... | ||
| 151 | fail: |
149 | fail: |
| 152 | page_table_unlock(AS, true); |
150 | page_table_unlock(AS, true); |
| 153 | tlb_refill_fail(istate); |
151 | tlb_refill_fail(istate); |
| 154 | } |
152 | } |
| 155 | 153 | ||
| 156 | /** Process TLB Invalid Exception |
154 | /** Process TLB Invalid Exception. |
| 157 | * |
- | |
| 158 | * Process TLB Invalid Exception. |
- | |
| 159 | * |
155 | * |
| 160 | * @param istate Interrupted register context. |
156 | * @param istate Interrupted register context. |
| 161 | */ |
157 | */ |
| 162 | void tlb_invalid(istate_t *istate) |
158 | void tlb_invalid(istate_t *istate) |
| 163 | { |
159 | { |
| 164 | tlb_index_t index; |
160 | tlb_index_t index; |
| 165 | uintptr_t badvaddr; |
161 | uintptr_t badvaddr; |
| Line 215... | Line 211... | ||
| 215 | /* |
211 | /* |
| 216 | * Record access to PTE. |
212 | * Record access to PTE. |
| 217 | */ |
213 | */ |
| 218 | pte->a = 1; |
214 | pte->a = 1; |
| 219 | 215 | ||
| 220 | tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, pte->pfn); |
216 | tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d, pte->cacheable, |
| - | 217 | pte->pfn); |
|
| 221 | 218 | ||
| 222 | /* |
219 | /* |
| 223 | * The entry is to be updated in TLB. |
220 | * The entry is to be updated in TLB. |
| 224 | */ |
221 | */ |
| 225 | if ((badvaddr/PAGE_SIZE) % 2 == 0) |
222 | if ((badvaddr / PAGE_SIZE) % 2 == 0) |
| 226 | cp0_entry_lo0_write(lo.value); |
223 | cp0_entry_lo0_write(lo.value); |
| 227 | else |
224 | else |
| 228 | cp0_entry_lo1_write(lo.value); |
225 | cp0_entry_lo1_write(lo.value); |
| 229 | cp0_pagemask_write(TLB_PAGE_MASK_16K); |
226 | cp0_pagemask_write(TLB_PAGE_MASK_16K); |
| 230 | tlbwi(); |
227 | tlbwi(); |
| Line 235... | Line 232... | ||
| 235 | fail: |
232 | fail: |
| 236 | page_table_unlock(AS, true); |
233 | page_table_unlock(AS, true); |
| 237 | tlb_invalid_fail(istate); |
234 | tlb_invalid_fail(istate); |
| 238 | } |
235 | } |
| 239 | 236 | ||
| 240 | /** Process TLB Modified Exception |
237 | /** Process TLB Modified Exception. |
| 241 | * |
- | |
| 242 | * Process TLB Modified Exception. |
- | |
| 243 | * |
238 | * |
| 244 | * @param istate Interrupted register context. |
239 | * @param istate Interrupted register context. |
| 245 | */ |
240 | */ |
| 246 | void tlb_modified(istate_t *istate) |
241 | void tlb_modified(istate_t *istate) |
| 247 | { |
242 | { |
| 248 | tlb_index_t index; |
243 | tlb_index_t index; |
| 249 | uintptr_t badvaddr; |
244 | uintptr_t badvaddr; |
| Line 306... | Line 301... | ||
| 306 | * Record access and write to PTE. |
301 | * Record access and write to PTE. |
| 307 | */ |
302 | */ |
| 308 | pte->a = 1; |
303 | pte->a = 1; |
| 309 | pte->d = 1; |
304 | pte->d = 1; |
| 310 | 305 | ||
| 311 | tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->w, pte->cacheable, pte->pfn); |
306 | tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->w, pte->cacheable, |
| - | 307 | pte->pfn); |
|
| 312 | 308 | ||
| 313 | /* |
309 | /* |
| 314 | * The entry is to be updated in TLB. |
310 | * The entry is to be updated in TLB. |
| 315 | */ |
311 | */ |
| 316 | if ((badvaddr/PAGE_SIZE) % 2 == 0) |
312 | if ((badvaddr / PAGE_SIZE) % 2 == 0) |
| 317 | cp0_entry_lo0_write(lo.value); |
313 | cp0_entry_lo0_write(lo.value); |
| 318 | else |
314 | else |
| 319 | cp0_entry_lo1_write(lo.value); |
315 | cp0_entry_lo1_write(lo.value); |
| 320 | cp0_pagemask_write(TLB_PAGE_MASK_16K); |
316 | cp0_pagemask_write(TLB_PAGE_MASK_16K); |
| 321 | tlbwi(); |
317 | tlbwi(); |
| Line 338... | Line 334... | ||
| 338 | symbol = s; |
334 | symbol = s; |
| 339 | s = get_symtab_entry(istate->ra); |
335 | s = get_symtab_entry(istate->ra); |
| 340 | if (s) |
336 | if (s) |
| 341 | sym2 = s; |
337 | sym2 = s; |
| 342 | 338 | ||
| 343 | fault_if_from_uspace(istate, "TLB Refill Exception on %p", cp0_badvaddr_read()); |
339 | fault_if_from_uspace(istate, "TLB Refill Exception on %p", |
| - | 340 | cp0_badvaddr_read()); |
|
| 344 | panic("%x: TLB Refill Exception at %x(%s<-%s)\n", cp0_badvaddr_read(), istate->epc, symbol, sym2); |
341 | panic("%x: TLB Refill Exception at %x(%s<-%s)\n", cp0_badvaddr_read(), |
| - | 342 | istate->epc, symbol, sym2); |
|
| 345 | } |
343 | } |
| 346 | 344 | ||
| 347 | 345 | ||
| 348 | void tlb_invalid_fail(istate_t *istate) |
346 | void tlb_invalid_fail(istate_t *istate) |
| 349 | { |
347 | { |
| 350 | char *symbol = ""; |
348 | char *symbol = ""; |
| 351 | 349 | ||
| 352 | char *s = get_symtab_entry(istate->epc); |
350 | char *s = get_symtab_entry(istate->epc); |
| 353 | if (s) |
351 | if (s) |
| 354 | symbol = s; |
352 | symbol = s; |
| 355 | fault_if_from_uspace(istate, "TLB Invalid Exception on %p", cp0_badvaddr_read()); |
353 | fault_if_from_uspace(istate, "TLB Invalid Exception on %p", |
| - | 354 | cp0_badvaddr_read()); |
|
| 356 | panic("%x: TLB Invalid Exception at %x(%s)\n", cp0_badvaddr_read(), istate->epc, symbol); |
355 | panic("%x: TLB Invalid Exception at %x(%s)\n", cp0_badvaddr_read(), |
| - | 356 | istate->epc, symbol); |
|
| 357 | } |
357 | } |
| 358 | 358 | ||
| 359 | void tlb_modified_fail(istate_t *istate) |
359 | void tlb_modified_fail(istate_t *istate) |
| 360 | { |
360 | { |
| 361 | char *symbol = ""; |
361 | char *symbol = ""; |
| 362 | 362 | ||
| 363 | char *s = get_symtab_entry(istate->epc); |
363 | char *s = get_symtab_entry(istate->epc); |
| 364 | if (s) |
364 | if (s) |
| 365 | symbol = s; |
365 | symbol = s; |
| 366 | fault_if_from_uspace(istate, "TLB Modified Exception on %p", cp0_badvaddr_read()); |
366 | fault_if_from_uspace(istate, "TLB Modified Exception on %p", |
| - | 367 | cp0_badvaddr_read()); |
|
| 367 | panic("%x: TLB Modified Exception at %x(%s)\n", cp0_badvaddr_read(), istate->epc, symbol); |
368 | panic("%x: TLB Modified Exception at %x(%s)\n", cp0_badvaddr_read(), |
| - | 369 | istate->epc, symbol); |
|
| 368 | } |
370 | } |
| 369 | 371 | ||
| 370 | /** Try to find PTE for faulting address |
372 | /** Try to find PTE for faulting address. |
| 371 | * |
373 | * |
| 372 | * Try to find PTE for faulting address. |
- | |
| 373 | * The AS->lock must be held on entry to this function. |
374 | * The AS->lock must be held on entry to this function. |
| 374 | * |
375 | * |
| 375 | * @param badvaddr Faulting virtual address. |
376 | * @param badvaddr Faulting virtual address. |
| 376 | * @param access Access mode that caused the fault. |
377 | * @param access Access mode that caused the fault. |
| 377 | * @param istate Pointer to interrupted state. |
378 | * @param istate Pointer to interrupted state. |
| 378 | * @param pfrc Pointer to variable where as_page_fault() return code will be stored. |
379 | * @param pfrc Pointer to variable where as_page_fault() return code |
| - | 380 | * will be stored. |
|
| 379 | * |
381 | * |
| 380 | * @return PTE on success, NULL otherwise. |
382 | * @return PTE on success, NULL otherwise. |
| 381 | */ |
383 | */ |
| - | 384 | pte_t * |
|
| 382 | pte_t *find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate, int *pfrc) |
385 | find_mapping_and_check(uintptr_t badvaddr, int access, istate_t *istate, |
| - | 386 | int *pfrc) |
|
| 383 | { |
387 | { |
| 384 | entry_hi_t hi; |
388 | entry_hi_t hi; |
| 385 | pte_t *pte; |
389 | pte_t *pte; |
| 386 | 390 | ||
| 387 | hi.value = cp0_entry_hi_read(); |
391 | hi.value = cp0_entry_hi_read(); |
| Line 439... | Line 443... | ||
| 439 | } |
443 | } |
| 440 | 444 | ||
| 441 | } |
445 | } |
| 442 | } |
446 | } |
| 443 | 447 | ||
| - | 448 | void |
|
| 444 | void tlb_prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable, uintptr_t pfn) |
449 | tlb_prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable, |
| - | 450 | uintptr_t pfn) |
|
| 445 | { |
451 | { |
| 446 | lo->value = 0; |
452 | lo->value = 0; |
| 447 | lo->g = g; |
453 | lo->g = g; |
| 448 | lo->v = v; |
454 | lo->v = v; |
| 449 | lo->d = d; |
455 | lo->d = d; |
| Line 478... | Line 484... | ||
| 478 | hi.value = cp0_entry_hi_read(); |
484 | hi.value = cp0_entry_hi_read(); |
| 479 | lo0.value = cp0_entry_lo0_read(); |
485 | lo0.value = cp0_entry_lo0_read(); |
| 480 | lo1.value = cp0_entry_lo1_read(); |
486 | lo1.value = cp0_entry_lo1_read(); |
| 481 | 487 | ||
| 482 | printf("%-2u %-4u %#6x %#4x %1u %1u %1u %1u %#6x\n", |
488 | printf("%-2u %-4u %#6x %#4x %1u %1u %1u %1u %#6x\n", |
| 483 | i, hi.asid, hi.vpn2, mask.mask, |
489 | i, hi.asid, hi.vpn2, mask.mask, |
| 484 | lo0.g, lo0.v, lo0.d, lo0.c, lo0.pfn); |
490 | lo0.g, lo0.v, lo0.d, lo0.c, lo0.pfn); |
| 485 | printf(" %1u %1u %1u %1u %#6x\n", |
491 | printf(" %1u %1u %1u %1u %#6x\n", |
| 486 | lo1.g, lo1.v, lo1.d, lo1.c, lo1.pfn); |
492 | lo1.g, lo1.v, lo1.d, lo1.c, lo1.pfn); |
| 487 | } |
493 | } |
| 488 | 494 | ||
| 489 | cp0_entry_hi_write(hi_save.value); |
495 | cp0_entry_hi_write(hi_save.value); |
| 490 | } |
496 | } |
| 491 | 497 | ||
| Line 558... | Line 564... | ||
| 558 | 564 | ||
| 559 | interrupts_restore(ipl); |
565 | interrupts_restore(ipl); |
| 560 | cp0_entry_hi_write(hi_save.value); |
566 | cp0_entry_hi_write(hi_save.value); |
| 561 | } |
567 | } |
| 562 | 568 | ||
| 563 | /** Invalidate TLB entries for specified page range belonging to specified address space. |
569 | /** Invalidate TLB entries for specified page range belonging to specified |
| - | 570 | * address space. |
|
| 564 | * |
571 | * |
| 565 | * @param asid Address space identifier. |
572 | * @param asid Address space identifier. |
| 566 | * @param page First page whose TLB entry is to be invalidated. |
573 | * @param page First page whose TLB entry is to be invalidated. |
| 567 | * @param cnt Number of entries to invalidate. |
574 | * @param cnt Number of entries to invalidate. |
| 568 | */ |
575 | */ |
| 569 | void tlb_invalidate_pages(asid_t asid, uintptr_t page, count_t cnt) |
576 | void tlb_invalidate_pages(asid_t asid, uintptr_t page, count_t cnt) |
| 570 | { |
577 | { |
| 571 | unsigned int i; |
578 | unsigned int i; |
| 572 | ipl_t ipl; |
579 | ipl_t ipl; |
| Line 586... | Line 593... | ||
| 586 | 593 | ||
| 587 | tlbp(); |
594 | tlbp(); |
| 588 | index.value = cp0_index_read(); |
595 | index.value = cp0_index_read(); |
| 589 | 596 | ||
| 590 | if (!index.p) { |
597 | if (!index.p) { |
| - | 598 | /* |
|
| 591 | /* Entry was found, index register contains valid index. */ |
599 | * Entry was found, index register contains valid |
| - | 600 | * index. |
|
| - | 601 | */ |
|
| 592 | tlbr(); |
602 | tlbr(); |
| 593 | 603 | ||
| 594 | lo0.value = cp0_entry_lo0_read(); |
604 | lo0.value = cp0_entry_lo0_read(); |
| 595 | lo1.value = cp0_entry_lo1_read(); |
605 | lo1.value = cp0_entry_lo1_read(); |
| 596 | 606 | ||