Changeset ad4b32c in mainline for kernel/arch/ia64/src/mm/tlb.c


Ignore:
Timestamp:
2009-09-04T21:50:59Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
309ede1
Parents:
7e266ff (diff), 40240b1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/ia64/src/mm/tlb.c

    r7e266ff rad4b32c  
    2727 */
    2828
    29 /** @addtogroup ia64mm 
     29/** @addtogroup ia64mm
    3030 * @{
    3131 */
    … …  
    5353#include <interrupt.h>
    5454
     55#define IO_FRAME_BASE 0xFFFFC000000
     56
    5557/** Invalidate all TLB entries. */
    5658void tlb_invalidate_all(void)
    … …  
    5961        uintptr_t adr;
    6062        uint32_t count1, count2, stride1, stride2;
    61                
     63       
    6264        unsigned int i, j;
    63                
     65       
    6466        adr = PAL_PTCE_INFO_BASE();
    6567        count1 = PAL_PTCE_INFO_COUNT1();
    … …  
    6769        stride1 = PAL_PTCE_INFO_STRIDE1();
    6870        stride2 = PAL_PTCE_INFO_STRIDE2();
    69                
     71       
    7072        ipl = interrupts_disable();
    71 
     73       
    7274        for (i = 0; i < count1; i++) {
    7375                for (j = 0; j < count2; j++) {
    7476                        asm volatile (
    75                                 "ptc.e %0 ;;"
    76                                 :
    77                                 : "r" (adr)
     77                                "ptc.e %[adr] ;;"
     78                                :: [adr] "r" (adr)
    7879                        );
    7980                        adr += stride2;
    … …  
    8182                adr += stride1;
    8283        }
    83 
     84       
    8485        interrupts_restore(ipl);
    85 
     86       
    8687        srlz_d();
    8788        srlz_i();
     89       
    8890#ifdef CONFIG_VHPT
    8991        vhpt_invalidate_all();
    90 #endif 
     92#endif
    9193}
    9294
    9395/** Invalidate entries belonging to an address space.
    9496 *
    95  * @param asid          Address space identifier.
     97 * @param asid Address space identifier.
     98 *
    9699 */
    97100void tlb_invalidate_asid(asid_t asid)
    … …  
    103106void tlb_invalidate_pages(asid_t asid, uintptr_t page, size_t cnt)
    104107{
    105         region_register rr;
     108        region_register_t rr;
    106109        bool restore_rr = false;
    107110        int b = 0;
    108111        int c = cnt;
    109 
     112       
    110113        uintptr_t va;
    111114        va = page;
    112 
     115       
    113116        rr.word = rr_read(VA2VRN(va));
    114117        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    117120                 * Save the old content of the register and replace the RID.
    118121                 */
    119                 region_register rr0;
    120 
     122                region_register_t rr0;
     123               
    121124                rr0 = rr;
    122125                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    126129        }
    127130       
    128         while(c >>= 1)
     131        while (c >>= 1)
    129132                b++;
    130133        b >>= 1;
    … …  
    169172                break;
    170173        }
    171         for(; va < (page + cnt * PAGE_SIZE); va += (1 << ps))
    172                 asm volatile ("ptc.l %0, %1;;" :: "r" (va), "r" (ps << 2));
     174       
     175        for (; va < (page + cnt * PAGE_SIZE); va += (1 << ps))
     176                asm volatile (
     177                        "ptc.l %[va], %[ps] ;;"
     178                        :: [va]"r" (va),
     179                           [ps] "r" (ps << 2)
     180                );
     181       
    173182        srlz_d();
    174183        srlz_i();
    … …  
    183192/** Insert data into data translation cache.
    184193 *
    185  * @param va            Virtual page address.
    186  * @param asid          Address space identifier.
    187  * @param entry         The rest of TLB entry as required by TLB insertion
    188  *                      format.
     194 * @param va    Virtual page address.
     195 * @param asid  Address space identifier.
     196 * @param entry The rest of TLB entry as required by TLB insertion
     197 *              format.
     198 *
    189199 */
    190200void dtc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry)
    … …  
    195205/** Insert data into instruction translation cache.
    196206 *
    197  * @param va            Virtual page address.
    198  * @param asid          Address space identifier.
    199  * @param entry         The rest of TLB entry as required by TLB insertion
    200  *                      format.
     207 * @param va    Virtual page address.
     208 * @param asid  Address space identifier.
     209 * @param entry The rest of TLB entry as required by TLB insertion
     210 *              format.
    201211 */
    202212void itc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry)
    … …  
    207217/** Insert data into instruction or data translation cache.
    208218 *
    209  * @param va            Virtual page address.
    210  * @param asid          Address space identifier.
    211  * @param entry         The rest of TLB entry as required by TLB insertion
    212  *                      format.
    213  * @param dtc           If true, insert into data translation cache, use
    214  *                      instruction translation cache otherwise.
     219 * @param va    Virtual page address.
     220 * @param asid  Address space identifier.
     221 * @param entry The rest of TLB entry as required by TLB insertion
     222 *              format.
     223 * @param dtc   If true, insert into data translation cache, use
     224 *              instruction translation cache otherwise.
     225 *
    215226 */
    216227void tc_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtc)
    217228{
    218         region_register rr;
     229        region_register_t rr;
    219230        bool restore_rr = false;
    220 
     231       
    221232        rr.word = rr_read(VA2VRN(va));
    222233        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    225236                 * Save the old content of the register and replace the RID.
    226237                 */
    227                 region_register rr0;
    228 
     238                region_register_t rr0;
     239               
    229240                rr0 = rr;
    230241                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    235246       
    236247        asm volatile (
    237                 "mov r8 = psr;;\n"
    238                 "rsm %0;;\n"                    /* PSR_IC_MASK */
    239                 "srlz.d;;\n"
    240                 "srlz.i;;\n"
    241                 "mov cr.ifa = %1\n"             /* va */
    242                 "mov cr.itir = %2;;\n"          /* entry.word[1] */
    243                 "cmp.eq p6,p7 = %4,r0;;\n"      /* decide between itc and dtc */
    244                 "(p6) itc.i %3;;\n"
    245                 "(p7) itc.d %3;;\n"
    246                 "mov psr.l = r8;;\n"
    247                 "srlz.d;;\n"
    248                 :
    249                 : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]),
    250                     "r" (entry.word[0]), "r" (dtc)
     248                "mov r8 = psr ;;\n"
     249                "rsm %[mask] ;;\n"                 /* PSR_IC_MASK */
     250                "srlz.d ;;\n"
     251                "srlz.i ;;\n"
     252                "mov cr.ifa = %[va]\n"             /* va */
     253                "mov cr.itir = %[word1] ;;\n"      /* entry.word[1] */
     254                "cmp.eq p6, p7 = %[dtc], r0 ;;\n"  /* decide between itc and dtc */
     255                "(p6) itc.i %[word0] ;;\n"
     256                "(p7) itc.d %[word0] ;;\n"
     257                "mov psr.l = r8 ;;\n"
     258                "srlz.d ;;\n"
     259                :: [mask] "i" (PSR_IC_MASK),
     260                   [va] "r" (va),
     261                   [word0] "r" (entry.word[0]),
     262                   [word1] "r" (entry.word[1]),
     263                   [dtc] "r" (dtc)
    251264                : "p6", "p7", "r8"
    252265        );
    … …  
    261274/** Insert data into instruction translation register.
    262275 *
    263  * @param va            Virtual page address.
    264  * @param asid          Address space identifier.
    265  * @param entry         The rest of TLB entry as required by TLB insertion
    266  *                      format.
    267  * @param tr            Translation register.
    268  */
    269 void
    270 itr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
     276 * @param va    Virtual page address.
     277 * @param asid  Address space identifier.
     278 * @param entry The rest of TLB entry as required by TLB insertion
     279 *              format.
     280 * @param tr    Translation register.
     281 *
     282 */
     283void itr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
    271284{
    272285        tr_mapping_insert(va, asid, entry, false, tr);
    … …  
    275288/** Insert data into data translation register.
    276289 *
    277  * @param va            Virtual page address.
    278  * @param asid          Address space identifier.
    279  * @param entry         The rest of TLB entry as required by TLB insertion
    280  *                      format.
    281  * @param tr            Translation register.
    282  */
    283 void
    284 dtr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
     290 * @param va    Virtual page address.
     291 * @param asid  Address space identifier.
     292 * @param entry The rest of TLB entry as required by TLB insertion
     293 *              format.
     294 * @param tr    Translation register.
     295 *
     296 */
     297void dtr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, size_t tr)
    285298{
    286299        tr_mapping_insert(va, asid, entry, true, tr);
    … …  
    289302/** Insert data into instruction or data translation register.
    290303 *
    291  * @param va            Virtual page address.
    292  * @param asid          Address space identifier.
    293  * @param entry         The rest of TLB entry as required by TLB insertion
    294  *                      format.
    295  * @param dtr           If true, insert into data translation register, use
    296  *                      instruction translation register otherwise.
    297  * @param tr            Translation register.
    298  */
    299 void
    300 tr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtr,
     304 * @param va    Virtual page address.
     305 * @param asid  Address space identifier.
     306 * @param entry The rest of TLB entry as required by TLB insertion
     307 *              format.
     308 * @param dtr   If true, insert into data translation register, use
     309 *              instruction translation register otherwise.
     310 * @param tr    Translation register.
     311 *
     312 */
     313void tr_mapping_insert(uintptr_t va, asid_t asid, tlb_entry_t entry, bool dtr,
    301314    size_t tr)
    302315{
    303         region_register rr;
     316        region_register_t rr;
    304317        bool restore_rr = false;
    305 
     318       
    306319        rr.word = rr_read(VA2VRN(va));
    307320        if ((restore_rr = (rr.map.rid != ASID2RID(asid, VA2VRN(va))))) {
    … …  
    310323                 * Save the old content of the register and replace the RID.
    311324                 */
    312                 region_register rr0;
    313 
     325                region_register_t rr0;
     326               
    314327                rr0 = rr;
    315328                rr0.map.rid = ASID2RID(asid, VA2VRN(va));
    … …  
    318331                srlz_i();
    319332        }
    320 
     333       
    321334        asm volatile (
    322                 "mov r8 = psr;;\n"
    323                 "rsm %0;;\n"                    /* PSR_IC_MASK */
    324                 "srlz.d;;\n"
    325                 "srlz.i;;\n"
    326                 "mov cr.ifa = %1\n"             /* va */                 
    327                 "mov cr.itir = %2;;\n"          /* entry.word[1] */
    328                 "cmp.eq p6,p7 = %5,r0;;\n"      /* decide between itr and dtr */
    329                 "(p6) itr.i itr[%4] = %3;;\n"
    330                 "(p7) itr.d dtr[%4] = %3;;\n"
    331                 "mov psr.l = r8;;\n"
    332                 "srlz.d;;\n"
    333                 :
    334                 : "i" (PSR_IC_MASK), "r" (va), "r" (entry.word[1]),
    335                     "r" (entry.word[0]), "r" (tr), "r" (dtr)
     335                "mov r8 = psr ;;\n"
     336                "rsm %[mask] ;;\n"                       /* PSR_IC_MASK */
     337                "srlz.d ;;\n"
     338                "srlz.i ;;\n"
     339                "mov cr.ifa = %[va]\n"                   /* va */
     340                "mov cr.itir = %[word1] ;;\n"            /* entry.word[1] */
     341                "cmp.eq p6, p7 = %[dtr], r0 ;;\n"        /* decide between itr and dtr */
     342                "(p6) itr.i itr[%[tr]] = %[word0] ;;\n"
     343                "(p7) itr.d dtr[%[tr]] = %[word0] ;;\n"
     344                "mov psr.l = r8 ;;\n"
     345                "srlz.d ;;\n"
     346                :: [mask] "i" (PSR_IC_MASK),
     347                   [va] "r" (va),
     348                   [word1] "r" (entry.word[1]),
     349                   [word0] "r" (entry.word[0]),
     350                   [tr] "r" (tr),
     351                   [dtr] "r" (dtr)
    336352                : "p6", "p7", "r8"
    337353        );
    … …  
    346362/** Insert data into DTLB.
    347363 *
    348  * @param page          Virtual page address including VRN bits.
    349  * @param frame         Physical frame address.
    350  * @param dtr           If true, insert into data translation register, use data
    351  *                      translation cache otherwise.
    352  * @param tr            Translation register if dtr is true, ignored otherwise.
    353  */
    354 void
    355 dtlb_kernel_mapping_insert(uintptr_t page, uintptr_t frame, bool dtr,
     364 * @param page  Virtual page address including VRN bits.
     365 * @param frame Physical frame address.
     366 * @param dtr   If true, insert into data translation register, use data
     367 *              translation cache otherwise.
     368 * @param tr    Translation register if dtr is true, ignored otherwise.
     369 *
     370 */
     371void dtlb_kernel_mapping_insert(uintptr_t page, uintptr_t frame, bool dtr,
    356372    size_t tr)
    357373{
    … …  
    361377        entry.word[1] = 0;
    362378       
    363         entry.p = true;                 /* present */
     379        entry.p = true;           /* present */
    364380        entry.ma = MA_WRITEBACK;
    365         entry.a = true;                 /* already accessed */
    366         entry.d = true;                 /* already dirty */
     381        entry.a = true;           /* already accessed */
     382        entry.d = true;           /* already dirty */
    367383        entry.pl = PL_KERNEL;
    368384        entry.ar = AR_READ | AR_WRITE;
    … …  
    380396 * Purge DTR entries used by the kernel.
    381397 *
    382  * @param page          Virtual page address including VRN bits.
    383  * @param width         Width of the purge in bits.
     398 * @param page  Virtual page address including VRN bits.
     399 * @param width Width of the purge in bits.
     400 *
    384401 */
    385402void dtr_purge(uintptr_t page, size_t width)
    386403{
    387         asm volatile ("ptr.d %0, %1\n" : : "r" (page), "r" (width << 2));
     404        asm volatile (
     405                "ptr.d %[page], %[width]\n"
     406                :: [page] "r" (page),
     407                   [width] "r" (width << 2)
     408        );
    388409}
    389410
    … …  
    391412/** Copy content of PTE into data translation cache.
    392413 *
    393  * @param t             PTE.
     414 * @param t PTE.
     415 *
    394416 */
    395417void dtc_pte_copy(pte_t *t)
    396418{
    397419        tlb_entry_t entry;
    398 
     420       
    399421        entry.word[0] = 0;
    400422        entry.word[1] = 0;
    … …  
    410432       
    411433        dtc_mapping_insert(t->page, t->as->asid, entry);
     434       
    412435#ifdef CONFIG_VHPT
    413436        vhpt_mapping_insert(t->page, t->as->asid, entry);
    414 #endif 
     437#endif
    415438}
    416439
    417440/** Copy content of PTE into instruction translation cache.
    418441 *
    419  * @param t             PTE.
     442 * @param t PTE.
     443 *
    420444 */
    421445void itc_pte_copy(pte_t *t)
    422446{
    423447        tlb_entry_t entry;
    424 
     448       
    425449        entry.word[0] = 0;
    426450        entry.word[1] = 0;
    … …  
    437461       
    438462        itc_mapping_insert(t->page, t->as->asid, entry);
     463       
    439464#ifdef CONFIG_VHPT
    440465        vhpt_mapping_insert(t->page, t->as->asid, entry);
    441 #endif 
     466#endif
    442467}
    443468
    444469/** Instruction TLB fault handler for faults with VHPT turned off.
    445470 *
    446  * @param vector                Interruption vector.
    447  * @param istate                Structure with saved interruption state.
     471 * @param vector Interruption vector.
     472 * @param istate Structure with saved interruption state.
     473 *
    448474 */
    449475void alternate_instruction_tlb_fault(uint64_t vector, istate_t *istate)
    450476{
    451         region_register rr;
     477        region_register_t rr;
    452478        rid_t rid;
    453479        uintptr_t va;
    454480        pte_t *t;
    455481       
    456         va = istate->cr_ifa;    /* faulting address */
     482        va = istate->cr_ifa; /* faulting address */
    457483        rr.word = rr_read(VA2VRN(va));
    458484        rid = rr.map.rid;
    459 
     485       
    460486        page_table_lock(AS, true);
    461487        t = page_mapping_find(AS, va);
    … …  
    473499                page_table_unlock(AS, true);
    474500                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    475                         fault_if_from_uspace(istate,"Page fault at %p.",va);
     501                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    476502                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    477503                            istate->cr_iip);
    … …  
    488514}
    489515
    490 #define IO_FRAME_BASE 0xFFFFC000000
    491 
    492516/**
    493517 * There is special handling of memory mapped legacy io, because of 4KB sized
    494518 * access for userspace.
    495519 *
    496  * @param va            Virtual address of page fault.
    497  * @param istate        Structure with saved interruption state.
    498  *
    499  * @return              One on success, zero on failure.
     520 * @param va     Virtual address of page fault.
     521 * @param istate Structure with saved interruption state.
     522 *
     523 * @return One on success, zero on failure.
     524 *
    500525 */
    501526static int try_memmap_io_insertion(uintptr_t va, istate_t *istate)
    … …  
    505530                        uint64_t io_page = (va & ((1 << IO_PAGE_WIDTH) - 1)) >>
    506531                            USPACE_IO_PAGE_WIDTH;
    507 
     532                       
    508533                        if (is_io_page_accessible(io_page)) {
    509534                                uint64_t page, frame;
    510 
     535                               
    511536                                page = IO_OFFSET +
    512537                                    (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    513538                                frame = IO_FRAME_BASE +
    514539                                    (1 << USPACE_IO_PAGE_WIDTH) * io_page;
    515 
     540                               
    516541                                tlb_entry_t entry;
    517        
     542                               
    518543                                entry.word[0] = 0;
    519544                                entry.word[1] = 0;
    520        
    521                                 entry.p = true;         /* present */
    522                                 entry.ma = MA_UNCACHEABLE;             
    523                                 entry.a = true;         /* already accessed */
    524                                 entry.d = true;         /* already dirty */
     545                               
     546                                entry.p = true;             /* present */
     547                                entry.ma = MA_UNCACHEABLE;
     548                                entry.a = true;             /* already accessed */
     549                                entry.d = true;             /* already dirty */
    525550                                entry.pl = PL_USER;
    526551                                entry.ar = AR_READ | AR_WRITE;
    527552                                entry.ppn = frame >> PPN_SHIFT;
    528553                                entry.ps = USPACE_IO_PAGE_WIDTH;
    529        
     554                               
    530555                                dtc_mapping_insert(page, TASK->as->asid, entry);
    531556                                return 1;
    … …  
    536561                }
    537562        }
    538                
     563       
    539564        return 0;
    540565}
    … …  
    542567/** Data TLB fault handler for faults with VHPT turned off.
    543568 *
    544  * @param vector        Interruption vector.
    545  * @param istate        Structure with saved interruption state.
     569 * @param vector Interruption vector.
     570 * @param istate Structure with saved interruption state.
     571 *
    546572 */
    547573void alternate_data_tlb_fault(uint64_t vector, istate_t *istate)
    548574{
    549         region_register rr;
    550         rid_t rid;
    551         uintptr_t va;
    552         pte_t *t;
    553        
    554         va = istate->cr_ifa;    /* faulting address */
    555         rr.word = rr_read(VA2VRN(va));
    556         rid = rr.map.rid;
     575        if (istate->cr_isr.sp) {
     576                /* Speculative load. Deffer the exception
     577                   until a more clever approach can be used.
     578                   
     579                   Currently if we try to find the mapping
     580                   for the speculative load while in the kernel,
     581                   we might introduce a livelock because of
     582                   the possibly invalid values of the address. */
     583                istate->cr_ipsr.ed = true;
     584                return;
     585        }
     586       
     587        uintptr_t va = istate->cr_ifa;  /* faulting address */
     588       
     589        region_register_t rr;
     590        rr.word = rr_read(VA2VRN(va));
     591        rid_t rid = rr.map.rid;
    557592        if (RID2ASID(rid) == ASID_KERNEL) {
    558593                if (VA2VRN(va) == VRN_KERNEL) {
    … …  
    565600                }
    566601        }
    567 
     602       
     603       
    568604        page_table_lock(AS, true);
    569         t = page_mapping_find(AS, va);
    570         if (t) {
     605        pte_t *entry = page_mapping_find(AS, va);
     606        if (entry) {
    571607                /*
    572608                 * The mapping was found in the software page hash table.
    573609                 * Insert it into data translation cache.
    574610                 */
    575                 dtc_pte_copy(t);
     611                dtc_pte_copy(entry);
    576612                page_table_unlock(AS, true);
    577613        } else {
    … …  
    579615                if (try_memmap_io_insertion(va, istate))
    580616                        return;
    581                 /*
    582                  * Forward the page fault to the address space page fault
     617               
     618                /*
     619                 * Forward the page fault to the address space page fault
    583620                 * handler.
    584621                 */
    585622                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    586                         fault_if_from_uspace(istate,"Page fault at %p.",va);
     623                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    587624                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    588625                            istate->cr_iip);
    … …  
    595632 * This fault should not occur.
    596633 *
    597  * @param vector        Interruption vector.
    598  * @param istate        Structure with saved interruption state.
     634 * @param vector Interruption vector.
     635 * @param istate Structure with saved interruption state.
     636 *
    599637 */
    600638void data_nested_tlb_fault(uint64_t vector, istate_t *istate)
    601639{
    602         panic("%s.", __func__);
     640        ASSERT(false);
    603641}
    604642
    605643/** Data Dirty bit fault handler.
    606644 *
    607  * @param vector        Interruption vector.
    608  * @param istate        Structure with saved interruption state.
     645 * @param vector Interruption vector.
     646 * @param istate Structure with saved interruption state.
     647 *
    609648 */
    610649void data_dirty_bit_fault(uint64_t vector, istate_t *istate)
    611650{
    612         region_register rr;
     651        region_register_t rr;
    613652        rid_t rid;
    614653        uintptr_t va;
    615654        pte_t *t;
    616655       
    617         va = istate->cr_ifa;    /* faulting address */
     656        va = istate->cr_ifa;  /* faulting address */
    618657        rr.word = rr_read(VA2VRN(va));
    619658        rid = rr.map.rid;
    620 
     659       
    621660        page_table_lock(AS, true);
    622661        t = page_mapping_find(AS, va);
    623         ASSERT(t && t->p);
    624         if (t && t->p && t->w) {
     662        ASSERT((t) && (t->p));
     663        if ((t) && (t->p) && (t->w)) {
    625664                /*
    626665                 * Update the Dirty bit in page tables and reinsert
    … …  
    631670        } else {
    632671                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    633                         fault_if_from_uspace(istate,"Page fault at %p.",va);
     672                        fault_if_from_uspace(istate, "Page fault at %p.", va);
    634673                        panic("%s: va=%p, rid=%d, iip=%p.", __func__, va, rid,
    635674                            istate->cr_iip);
    … …  
    641680/** Instruction access bit fault handler.
    642681 *
    643  * @param vector        Interruption vector.
    644  * @param istate        Structure with saved interruption state.
     682 * @param vector Interruption vector.
     683 * @param istate Structure with saved interruption state.
     684 *
    645685 */
    646686void instruction_access_bit_fault(uint64_t vector, istate_t *istate)
    647687{
    648         region_register rr;
     688        region_register_t rr;
    649689        rid_t rid;
    650690        uintptr_t va;
    651         pte_t *t;       
    652 
    653         va = istate->cr_ifa;    /* faulting address */
     691        pte_t *t;
     692       
     693        va = istate->cr_ifa;  /* faulting address */
    654694        rr.word = rr_read(VA2VRN(va));
    655695        rid = rr.map.rid;
    656 
     696       
    657697        page_table_lock(AS, true);
    658698        t = page_mapping_find(AS, va);
    659         ASSERT(t && t->p);
    660         if (t && t->p && t->x) {
     699        ASSERT((t) && (t->p));
     700        if ((t) && (t->p) && (t->x)) {
    661701                /*
    662702                 * Update the Accessed bit in page tables and reinsert
    … …  
    679719 * @param vector Interruption vector.
    680720 * @param istate Structure with saved interruption state.
     721 *
    681722 */
    682723void data_access_bit_fault(uint64_t vector, istate_t *istate)
    683724{
    684         region_register rr;
     725        region_register_t rr;
    685726        rid_t rid;
    686727        uintptr_t va;
    687728        pte_t *t;
    688 
    689         va = istate->cr_ifa;    /* faulting address */
     729       
     730        va = istate->cr_ifa;  /* faulting address */
    690731        rr.word = rr_read(VA2VRN(va));
    691732        rid = rr.map.rid;
    692 
     733       
    693734        page_table_lock(AS, true);
    694735        t = page_mapping_find(AS, va);
    695         ASSERT(t && t->p);
    696         if (t && t->p) {
     736        ASSERT((t) && (t->p));
     737        if ((t) && (t->p)) {
    697738                /*
    698739                 * Update the Accessed bit in page tables and reinsert
    … …  
    715756 * @param vector Interruption vector.
    716757 * @param istate Structure with saved interruption state.
     758 *
    717759 */
    718760void data_access_rights_fault(uint64_t vector, istate_t *istate)
    719761{
    720         region_register rr;
     762        region_register_t rr;
    721763        rid_t rid;
    722764        uintptr_t va;
    723765        pte_t *t;
    724 
    725         va = istate->cr_ifa;    /* faulting address */
     766       
     767        va = istate->cr_ifa;  /* faulting address */
    726768        rr.word = rr_read(VA2VRN(va));
    727769        rid = rr.map.rid;
    728 
     770       
    729771        /*
    730772         * Assume a write to a read-only page.
    … …  
    732774        page_table_lock(AS, true);
    733775        t = page_mapping_find(AS, va);
    734         ASSERT(t && t->p);
     776        ASSERT((t) && (t->p));
    735777        ASSERT(!t->w);
    736778        if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    … …  
    746788 * @param vector Interruption vector.
    747789 * @param istate Structure with saved interruption state.
     790 *
    748791 */
    749792void page_not_present(uint64_t vector, istate_t *istate)
    750793{
    751         region_register rr;
     794        region_register_t rr;
    752795        rid_t rid;
    753796        uintptr_t va;
    754797        pte_t *t;
    755798       
    756         va = istate->cr_ifa;    /* faulting address */
     799        va = istate->cr_ifa;  /* faulting address */
    757800        rr.word = rr_read(VA2VRN(va));
    758801        rid = rr.map.rid;
    759 
     802       
    760803        page_table_lock(AS, true);
    761804        t = page_mapping_find(AS, va);
Note: See TracChangeset for help on using the changeset viewer.