Ignore:
File:
1 edited

Legend:

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

    ra35b458 r1b20da0  
    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.