Changeset 567807b1 in mainline for arch


Ignore:
Timestamp:
2006-05-24T17:03:29Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8d6bc2d5
Parents:
82da5f5
Message:

Modify the hierarchy of page fault handlers to pass access mode that caused the fault.
Architectures are required to pass either PF_ACCESS_READ, PF_ACCESS_WRITE or PF_ACCESS_EXEC
to as_page_fault(), depending on the cause of the fault.

Location:
arch
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • arch/amd64/include/mm/page.h

    r82da5f5 r567807b1  
    107107#ifndef __ASM__
    108108
     109/* Page fault error codes. */
     110
     111/** When bit on this position is 0, the page fault was caused by a not-present page. */
     112#define PFERR_CODE_P            (1<<0) 
     113
     114/** When bit on this position is 1, the page fault was caused by a write. */
     115#define PFERR_CODE_RW           (1<<1)
     116
     117/** When bit on this position is 1, the page fault was caused in user mode. */
     118#define PFERR_CODE_US           (1<<2)
     119
     120/** When bit on this position is 1, a reserved bit was set in page directory. */
     121#define PFERR_CODE_RSVD         (1<<3)
     122
     123/** When bit on this position os 1, the page fault was caused during instruction fecth. */
     124#define PFERR_CODE_ID           (1<<4)
     125
    109126/** Page Table Entry. */
    110127struct page_specifier {

  • arch/amd64/src/mm/page.c

    r82da5f5 r567807b1  
    169169{
    170170        __address page;
     171        pf_access_t access;
    171172       
    172173        page = read_cr2();
    173         if (as_page_fault(page, istate) == AS_PF_FAULT) {
     174       
     175        if (istate->error_word & PFERR_CODE_RSVD)
     176                panic("Reserved bit set in page table entry.\n");
     177       
     178        if (istate->error_word & PFERR_CODE_RW)
     179                access = PF_ACCESS_WRITE;
     180        else if (istate->error_word & PFERR_CODE_ID)
     181                access = PF_ACCESS_EXEC;
     182        else
     183                access = PF_ACCESS_READ;
     184       
     185        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
    174186                print_info_errcode(n, istate);
    175187                printf("Page fault address: %llX\n", page);

  • arch/ia32/include/interrupt.h

    r82da5f5 r567807b1  
    9393extern void (* eoi_function)(void);
    9494
     95extern void PRINT_INFO_ERRCODE(istate_t *istate);
    9596extern void null_interrupt(int n, istate_t *istate);
    9697extern void gp_fault(int n, istate_t *istate);
    … …  
    9899extern void ss_fault(int n, istate_t *istate);
    99100extern void simd_fp_exception(int n, istate_t *istate);
    100 extern void page_fault(int n, istate_t *istate);
    101101extern void syscall(int n, istate_t *istate);
    102102extern void tlb_shootdown_ipi(int n, istate_t *istate);

  • arch/ia32/include/mm/page.h

    r82da5f5 r567807b1  
    9191#include <typedefs.h>
    9292
     93/* Page fault error codes. */
     94
     95/** When bit on this position is 0, the page fault was caused by a not-present page. */
     96#define PFERR_CODE_P            (1<<0)
     97
     98/** When bit on this position is 1, the page fault was caused by a write. */
     99#define PFERR_CODE_RW           (1<<1)
     100
     101/** When bit on this position is 1, the page fault was caused in user mode. */
     102#define PFERR_CODE_US           (1<<2)
     103
     104/** When bit on this position is 1, a reserved bit was set in page directory. */
     105#define PFERR_CODE_RSVD         (1<<3) 
     106
    93107/** Page Table Entry. */
    94108struct page_specifier {
    … …  
    139153
    140154extern void page_arch_init(void);
     155extern void page_fault(int n, istate_t *istate);
    141156
    142157#endif /* __ASM__ */

  • arch/ia32/src/interrupt.c

    r82da5f5 r567807b1  
    5555void (* eoi_function)(void) = NULL;
    5656
    57 static void PRINT_INFO_ERRCODE(istate_t *istate)
     57void PRINT_INFO_ERRCODE(istate_t *istate)
    5858{
    5959        char *symbol = get_symtab_entry(istate->eip);
    … …  
    140140}
    141141
    142 void page_fault(int n, istate_t *istate)
    143 {
    144         __address page;
    145 
    146         page = read_cr2();
    147         if (as_page_fault(page, istate) == AS_PF_FAULT) {
    148                 PRINT_INFO_ERRCODE(istate);
    149                 printf("page fault address: %#x\n", page);
    150                 panic("page fault\n");
    151         }
    152 }
    153 
    154142void syscall(int n, istate_t *istate)
    155143{

  • arch/ia32/src/mm/page.c

    r82da5f5 r567807b1  
    4444#include <interrupt.h>
    4545
    46 
    4746void page_arch_init(void)
    4847{
    … …  
    8887        return virtaddr;
    8988}
     89
     90void page_fault(int n, istate_t *istate)
     91{
     92        __address page;
     93        pf_access_t access;
     94       
     95        page = read_cr2();
     96               
     97        if (istate->error_word & PFERR_CODE_RSVD)
     98                panic("Reserved bit set in page directory.\n");
     99
     100        if (istate->error_word & PFERR_CODE_RW)
     101                access = PF_ACCESS_WRITE;
     102        else
     103                access = PF_ACCESS_READ;
     104
     105        if (as_page_fault(page, access, istate) == AS_PF_FAULT) {
     106                PRINT_INFO_ERRCODE(istate);
     107                printf("page fault address: %#x\n", page);
     108                panic("page fault\n");
     109        }
     110}

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

    r82da5f5 r567807b1  
    430430{
    431431        region_register rr;
     432        rid_t rid;
    432433        __address va;
    433434        pte_t *t;
    434435       
    435436        va = istate->cr_ifa;    /* faulting address */
     437        rr.word = rr_read(VA2VRN(va));
     438        rid = rr.map.rid;
     439
    436440        page_table_lock(AS, true);
    437441        t = page_mapping_find(AS, va);
    … …  
    448452                 */
    449453                page_table_unlock(AS, true);
    450                 if (as_page_fault(va, istate) == AS_PF_FAULT) {
    451                         panic("%s: va=%p, rid=%d, iip=%p\n", __FUNCTION__, istate->cr_ifa, rr.map.rid, istate->cr_iip);
     454                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
     455                        panic("%s: va=%p, rid=%d, iip=%p\n", __FUNCTION__, va, rid, istate->cr_iip);
    452456                }
    453457        }
    … …  
    494498                 */
    495499                page_table_unlock(AS, true);
    496                 if (as_page_fault(va, istate) == AS_PF_FAULT) {
     500                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    497501                        panic("%s: va=%p, rid=%d, iip=%p\n", __FUNCTION__, va, rid, istate->cr_iip);
    498502                }
    … …  
    519523void data_dirty_bit_fault(__u64 vector, istate_t *istate)
    520524{
     525        region_register rr;
     526        rid_t rid;
     527        __address va;
    521528        pte_t *t;
     529       
     530        va = istate->cr_ifa;    /* faulting address */
     531        rr.word = rr_read(VA2VRN(va));
     532        rid = rr.map.rid;
    522533
    523534        page_table_lock(AS, true);
    524         t = page_mapping_find(AS, istate->cr_ifa);
     535        t = page_mapping_find(AS, va);
     536        ASSERT(t && t->p);
     537        if (t && t->p && t->w) {
     538                /*
     539                 * Update the Dirty bit in page tables and reinsert
     540                 * the mapping into DTC.
     541                 */
     542                t->d = true;
     543                dtc_pte_copy(t);
     544        } else {
     545                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
     546                        panic("%s: va=%p, rid=%d, iip=%p\n", __FUNCTION__, va, rid, istate->cr_iip);
     547                        t->d = true;
     548                        dtc_pte_copy(t);
     549                }
     550        }
     551        page_table_unlock(AS, true);
     552}
     553
     554/** Instruction access bit fault handler.
     555 *
     556 * @param vector Interruption vector.
     557 * @param istate Structure with saved interruption state.
     558 */
     559void instruction_access_bit_fault(__u64 vector, istate_t *istate)
     560{
     561        region_register rr;
     562        rid_t rid;
     563        __address va;
     564        pte_t *t;       
     565
     566        va = istate->cr_ifa;    /* faulting address */
     567        rr.word = rr_read(VA2VRN(va));
     568        rid = rr.map.rid;
     569
     570        page_table_lock(AS, true);
     571        t = page_mapping_find(AS, va);
     572        ASSERT(t && t->p);
     573        if (t && t->p && t->x) {
     574                /*
     575                 * Update the Accessed bit in page tables and reinsert
     576                 * the mapping into ITC.
     577                 */
     578                t->a = true;
     579                itc_pte_copy(t);
     580        } else {
     581                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
     582                        panic("%s: va=%p, rid=%d, iip=%p\n", __FUNCTION__, va, rid, istate->cr_iip);
     583                        t->a = true;
     584                        itc_pte_copy(t);
     585                }
     586        }
     587        page_table_unlock(AS, true);
     588}
     589
     590/** Data access bit fault handler.
     591 *
     592 * @param vector Interruption vector.
     593 * @param istate Structure with saved interruption state.
     594 */
     595void data_access_bit_fault(__u64 vector, istate_t *istate)
     596{
     597        region_register rr;
     598        rid_t rid;
     599        __address va;
     600        pte_t *t;
     601
     602        va = istate->cr_ifa;    /* faulting address */
     603        rr.word = rr_read(VA2VRN(va));
     604        rid = rr.map.rid;
     605
     606        page_table_lock(AS, true);
     607        t = page_mapping_find(AS, va);
    525608        ASSERT(t && t->p);
    526609        if (t && t->p) {
    527610                /*
    528                  * Update the Dirty bit in page tables and reinsert
     611                 * Update the Accessed bit in page tables and reinsert
    529612                 * the mapping into DTC.
    530613                 */
    531                 t->d = true;
     614                t->a = true;
    532615                dtc_pte_copy(t);
     616        } else {
     617                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
     618                        panic("%s: va=%p, rid=%d, iip=%p\n", __FUNCTION__, va, rid, istate->cr_iip);
     619                        t->a = true;
     620                        itc_pte_copy(t);
     621                }
    533622        }
    534623        page_table_unlock(AS, true);
    535624}
    536625
    537 /** Instruction access bit fault handler.
     626/** Page not present fault handler.
    538627 *
    539628 * @param vector Interruption vector.
    540629 * @param istate Structure with saved interruption state.
    541630 */
    542 void instruction_access_bit_fault(__u64 vector, istate_t *istate)
    543 {
    544         pte_t *t;
    545 
    546         page_table_lock(AS, true);
    547         t = page_mapping_find(AS, istate->cr_ifa);
    548         ASSERT(t && t->p);
    549         if (t && t->p) {
    550                 /*
    551                  * Update the Accessed bit in page tables and reinsert
    552                  * the mapping into ITC.
    553                  */
    554                 t->a = true;
    555                 itc_pte_copy(t);
    556         }
    557         page_table_unlock(AS, true);
    558 }
    559 
    560 /** Data access bit fault handler.
    561  *
    562  * @param vector Interruption vector.
    563  * @param istate Structure with saved interruption state.
    564  */
    565 void data_access_bit_fault(__u64 vector, istate_t *istate)
    566 {
    567         pte_t *t;
    568 
    569         page_table_lock(AS, true);
    570         t = page_mapping_find(AS, istate->cr_ifa);
    571         ASSERT(t && t->p);
    572         if (t && t->p) {
    573                 /*
    574                  * Update the Accessed bit in page tables and reinsert
    575                  * the mapping into DTC.
    576                  */
    577                 t->a = true;
    578                 dtc_pte_copy(t);
    579         }
    580         page_table_unlock(AS, true);
    581 }
    582 
    583 /** Page not present fault handler.
    584  *
    585  * @param vector Interruption vector.
    586  * @param istate Structure with saved interruption state.
    587  */
    588631void page_not_present(__u64 vector, istate_t *istate)
    589632{
    590633        region_register rr;
     634        rid_t rid;
    591635        __address va;
    592636        pte_t *t;
    593637       
    594638        va = istate->cr_ifa;    /* faulting address */
     639        rr.word = rr_read(VA2VRN(va));
     640        rid = rr.map.rid;
     641
    595642        page_table_lock(AS, true);
    596643        t = page_mapping_find(AS, va);
    … …  
    609656        } else {
    610657                page_table_unlock(AS, true);
    611                 if (as_page_fault(va, istate) == AS_PF_FAULT) {
    612                         panic("%s: va=%p, rid=%d\n", __FUNCTION__, va, rr.map.rid);
    613                 }
    614         }
    615 }
     658                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
     659                        panic("%s: va=%p, rid=%d\n", __FUNCTION__, va, rid);
     660                }
     661        }
     662}

  • arch/mips32/src/mm/tlb.c

    r82da5f5 r567807b1  
    4545static void tlb_modified_fail(istate_t *istate);
    4646
    47 static pte_t *find_mapping_and_check(__address badvaddr, istate_t *istate, int *pfrc);
     47static pte_t *find_mapping_and_check(__address badvaddr, int access, istate_t *istate, int *pfrc);
    4848
    4949static void prepare_entry_lo(entry_lo_t *lo, bool g, bool v, bool d, bool cacheable, __address pfn);
    … …  
    102102        page_table_lock(AS, true);
    103103
    104         pte = find_mapping_and_check(badvaddr, istate, &pfrc);
     104        pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
    105105        if (!pte) {
    106106                switch (pfrc) {
    … …  
    187187        }
    188188
    189         pte = find_mapping_and_check(badvaddr, istate, &pfrc);
     189        pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
    190190        if (!pte) {
    191191                switch (pfrc) {
    … …  
    271271        }
    272272
    273         pte = find_mapping_and_check(badvaddr, istate, &pfrc);
     273        pte = find_mapping_and_check(badvaddr, PF_ACCESS_WRITE, istate, &pfrc);
    274274        if (!pte) {
    275275                switch (pfrc) {
    … …  
    367367 *
    368368 * @param badvaddr Faulting virtual address.
     369 * @param access Access mode that caused the fault.
    369370 * @param istate Pointer to interrupted state.
    370371 * @param pfrc Pointer to variable where as_page_fault() return code will be stored.
    … …  
    372373 * @return PTE on success, NULL otherwise.
    373374 */
    374 pte_t *find_mapping_and_check(__address badvaddr, istate_t *istate, int *pfrc)
     375pte_t *find_mapping_and_check(__address badvaddr, int access, istate_t *istate, int *pfrc)
    375376{
    376377        entry_hi_t hi;
    … …  
    405406                 */
    406407                page_table_unlock(AS, true);
    407                 switch (rc = as_page_fault(badvaddr, istate)) {
     408                switch (rc = as_page_fault(badvaddr, access, istate)) {
    408409                case AS_PF_OK:
    409410                        /*

  • arch/ppc32/src/mm/page.c

    r82da5f5 r567807b1  
    5454 * @param lock     Lock/unlock the address space.
    5555 * @param badvaddr Faulting virtual address.
     56 * @param access   Access mode that caused the fault.
    5657 * @param istate   Pointer to interrupted state.
    5758 * @param pfrc     Pointer to variable where as_page_fault() return code will be stored.
    … …  
    5960 *
    6061 */
    61 static pte_t *find_mapping_and_check(as_t *as, bool lock, __address badvaddr, istate_t *istate, int *pfcr)
     62static pte_t *find_mapping_and_check(as_t *as, bool lock, __address badvaddr, int access,
     63                                     istate_t *istate, int *pfcr)
    6264{
    6365        /*
    … …  
    7981                 */
    8082                page_table_unlock(as, lock);
    81                 switch (rc = as_page_fault(badvaddr, istate)) {
     83                switch (rc = as_page_fault(badvaddr, access, istate)) {
    8284                        case AS_PF_OK:
    8385                                /*
    … …  
    212214        page_table_lock(as, lock);
    213215       
    214         pte = find_mapping_and_check(as, lock, badvaddr, istate, &pfcr);
     216        pte = find_mapping_and_check(as, lock, badvaddr, PF_ACCESS_READ /* FIXME */, istate, &pfcr);
    215217        if (!pte) {
    216218                switch (pfcr) {

  • arch/ppc64/src/mm/page.c

    r82da5f5 r567807b1  
    5454 * @param lock     Lock/unlock the address space.
    5555 * @param badvaddr Faulting virtual address.
     56 * @param access   Access mode that caused the fault.
    5657 * @param istate   Pointer to interrupted state.
    5758 * @param pfrc     Pointer to variable where as_page_fault() return code will be stored.
    … …  
    5960 *
    6061 */
    61 static pte_t *find_mapping_and_check(as_t *as, bool lock, __address badvaddr, istate_t *istate, int *pfcr)
     62static pte_t *find_mapping_and_check(as_t *as, bool lock, __address badvaddr, int access,
     63                                     istate_t *istate, int *pfcr)
    6264{
    6365        /*
    … …  
    7981                 */
    8082                page_table_unlock(as, lock);
    81                 switch (rc = as_page_fault(badvaddr, istate)) {
     83                switch (rc = as_page_fault(badvaddr, access, istate)) {
    8284                        case AS_PF_OK:
    8385                                /*
    … …  
    212214        page_table_lock(as, lock);
    213215       
    214         pte = find_mapping_and_check(as, lock, badvaddr, istate, &pfcr);
     216        pte = find_mapping_and_check(as, lock, badvaddr, PF_ACCESS_READ /* FIXME */, istate, &pfcr);
    215217        if (!pte) {
    216218                switch (pfcr) {
Note: See TracChangeset for help on using the changeset viewer.