Subversion Repositories HelenOS

Rev

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