Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/ia64/src/mm/tlb.c

    r1b20da0 ra35b458  
    6161        uintptr_t adr;
    6262        uint32_t count1, count2, stride1, stride2;
    63        
     63
    6464        unsigned int i, j;
    65        
     65
    6666        adr = PAL_PTCE_INFO_BASE();
    6767        count1 = PAL_PTCE_INFO_COUNT1();
     
    6969        stride1 = PAL_PTCE_INFO_STRIDE1();
    7070        stride2 = PAL_PTCE_INFO_STRIDE2();
    71        
     71
    7272        ipl = interrupts_disable();
    73        
     73
    7474        for (i = 0; i < count1; i++) {
    7575                for (j = 0; j < count2; j++) {
     
    8282                adr += stride1;
    8383        }
    84        
     84
    8585        interrupts_restore(ipl);
    86        
     86
    8787        srlz_d();
    8888        srlz_i();
    89        
     89
    9090#ifdef CONFIG_VHPT
    9191        vhpt_invalidate_all();
     
    110110        int b = 0;
    111111        int c = cnt;
    112        
     112
    113113        uintptr_t va;
    114114        va = page;
    115        
     115
    116116        rr.word = rr_read(VA2VRN(page));
    117117        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(page))))) {
     
    121121                 */
    122122                region_register_t rr0;
    123                
     123
    124124                rr0 = rr;
    125125                rr0.map.rid = ASID2RID(asid, VA2VRN(page));
     
    128128                srlz_i();
    129129        }
    130        
     130
    131131        while (c >>= 1)
    132132                b++;
    133133        b >>= 1;
    134134        uint64_t ps;
    135        
     135
    136136        switch (b) {
    137137        case 0: /* cnt 1 - 3 */
     
    172172                break;
    173173        }
    174        
     174
    175175        for (; va < (page + cnt * PAGE_SIZE); va += (1UL << ps))
    176176                asm volatile (
     
    179179                           [ps] "r" (ps << 2)
    180180                );
    181        
     181
    182182        srlz_d();
    183183        srlz_i();
    184        
     184
    185185        if (restore_rr) {
    186186                rr_write(VA2VRN(page), rr.word);
     
    229229        region_register_t rr;
    230230        bool restore_rr = false;
    231        
     231
    232232        rr.word = rr_read(VA2VRN(va));
    233233        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
     
    237237                 */
    238238                region_register_t rr0;
    239                
     239
    240240                rr0 = rr;
    241241                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
     
    244244                srlz_i();
    245245        }
    246        
     246
    247247        asm volatile (
    248248                "mov r8 = psr ;;\n"
     
    264264                : "p6", "p7", "r8"
    265265        );
    266        
     266
    267267        if (restore_rr) {
    268268                rr_write(VA2VRN(va), rr.word);
     
    316316        region_register_t rr;
    317317        bool restore_rr = false;
    318        
     318
    319319        rr.word = rr_read(VA2VRN(va));
    320320        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
     
    324324                 */
    325325                region_register_t rr0;
    326                
     326
    327327                rr0 = rr;
    328328                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
     
    331331                srlz_i();
    332332        }
    333        
     333
    334334        asm volatile (
    335335                "mov r8 = psr ;;\n"
     
    352352                : "p6", "p7", "r8"
    353353        );
    354        
     354
    355355        if (restore_rr) {
    356356                rr_write(VA2VRN(va), rr.word);
     
    373373{
    374374        tlb_entry_t entry;
    375        
     375
    376376        entry.word[0] = 0;
    377377        entry.word[1] = 0;
    378        
     378
    379379        entry.p = true;           /* present */
    380380        entry.ma = MA_WRITEBACK;
     
    385385        entry.ppn = frame >> PPN_SHIFT;
    386386        entry.ps = PAGE_WIDTH;
    387        
     387
    388388        if (dtr)
    389389                dtr_mapping_insert(page, ASID_KERNEL, entry, tr);
     
    418418{
    419419        tlb_entry_t entry;
    420        
     420
    421421        entry.word[0] = 0;
    422422        entry.word[1] = 0;
    423        
     423
    424424        entry.p = t->p;
    425425        entry.ma = t->c ? MA_WRITEBACK : MA_UNCACHEABLE;
     
    430430        entry.ppn = t->frame >> PPN_SHIFT;
    431431        entry.ps = PAGE_WIDTH;
    432        
     432
    433433        dtc_mapping_insert(t->page, t->as->asid, entry);
    434        
     434
    435435#ifdef CONFIG_VHPT
    436436        vhpt_mapping_insert(t->page, t->as->asid, entry);
     
    446446{
    447447        tlb_entry_t entry;
    448        
     448
    449449        entry.word[0] = 0;
    450450        entry.word[1] = 0;
    451        
     451
    452452        assert(t->x);
    453        
     453
    454454        entry.p = t->p;
    455455        entry.ma = t->c ? MA_WRITEBACK : MA_UNCACHEABLE;
     
    459459        entry.ppn = t->frame >> PPN_SHIFT;
    460460        entry.ps = PAGE_WIDTH;
    461        
     461
    462462        itc_mapping_insert(t->page, t->as->asid, entry);
    463        
     463
    464464#ifdef CONFIG_VHPT
    465465        vhpt_mapping_insert(t->page, t->as->asid, entry);
     
    486486        uintptr_t va;
    487487        pte_t t;
    488        
     488
    489489        va = istate->cr_ifa; /* faulting address */
    490        
     490
    491491        assert(!is_kernel_fault(va));
    492492
     
    532532                        uint64_t io_page = (va & ((1 << LEGACYIO_PAGE_WIDTH) - 1)) >>
    533533                            LEGACYIO_SINGLE_PAGE_WIDTH;
    534                        
     534
    535535                        if (is_io_page_accessible(io_page)) {
    536536                                uint64_t page, frame;
    537                                
     537
    538538                                page = LEGACYIO_USER_BASE +
    539539                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
    540540                                frame = LEGACYIO_PHYS_BASE +
    541541                                    (1 << LEGACYIO_SINGLE_PAGE_WIDTH) * io_page;
    542                                
     542
    543543                                tlb_entry_t entry;
    544                                
     544
    545545                                entry.word[0] = 0;
    546546                                entry.word[1] = 0;
    547                                
     547
    548548                                entry.p = true;             /* present */
    549549                                entry.ma = MA_UNCACHEABLE;
     
    554554                                entry.ppn = frame >> PPN_SHIFT;
    555555                                entry.ps = LEGACYIO_SINGLE_PAGE_WIDTH;
    556                                
     556
    557557                                dtc_mapping_insert(page, TASK->as->asid, entry);
    558558                                return 1;
     
    563563                }
    564564        }
    565        
     565
    566566        return 0;
    567567}
     
    586586                return;
    587587        }
    588        
     588
    589589        uintptr_t va = istate->cr_ifa;  /* faulting address */
    590590        as_t *as = AS;
    591        
     591
    592592        if (is_kernel_fault(va)) {
    593593                if (va < end_of_identity) {
     
    601601                }
    602602        }
    603        
    604        
     603
     604
    605605        pte_t t;
    606606        bool found = page_mapping_find(as, va, true, &t);
     
    616616                if (try_memmap_io_insertion(va, istate))
    617617                        return;
    618                
     618
    619619                /*
    620620                 * Forward the page fault to the address space page fault
     
    649649        pte_t t;
    650650        as_t *as = AS;
    651        
     651
    652652        va = istate->cr_ifa;  /* faulting address */
    653        
     653
    654654        if (is_kernel_fault(va))
    655655                as = AS_KERNEL;
     
    683683        uintptr_t va;
    684684        pte_t t;
    685        
     685
    686686        va = istate->cr_ifa;  /* faulting address */
    687687
    688688        assert(!is_kernel_fault(va));
    689        
     689
    690690        bool found = page_mapping_find(AS, va, true, &t);
    691691
     
    717717        pte_t t;
    718718        as_t *as = AS;
    719        
     719
    720720        va = istate->cr_ifa;  /* faulting address */
    721        
     721
    722722        if (is_kernel_fault(va))
    723723                as = AS_KERNEL;
     
    755755        uintptr_t va;
    756756        pte_t t;
    757        
     757
    758758        va = istate->cr_ifa;  /* faulting address */
    759759
    760760        assert(!is_kernel_fault(va));
    761        
     761
    762762        /*
    763763         * Assume a write to a read-only page.
     
    782782        uintptr_t va;
    783783        pte_t t;
    784        
     784
    785785        va = istate->cr_ifa;  /* faulting address */
    786        
     786
    787787        assert(!is_kernel_fault(va));
    788788
     
    790790
    791791        assert(found);
    792        
     792
    793793        if (t.p) {
    794794                /*
Note: See TracChangeset for help on using the changeset viewer.