Ignore:
File:
1 edited

Legend:

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

    r9928240 r560b81c  
    484484{
    485485        uintptr_t va;
    486         pte_t *t;
     486        pte_t t;
    487487       
    488488        va = istate->cr_ifa; /* faulting address */
     
    490490        ASSERT(!is_kernel_fault(va));
    491491
    492         t = page_mapping_find(AS, va, true);
    493         if (t) {
     492        bool found = page_mapping_find(AS, va, true, &t);
     493        if (found) {
     494                ASSERT(t.p);
     495
    494496                /*
    495497                 * The mapping was found in software page hash table.
    496498                 * Insert it into data translation cache.
    497499                 */
    498                 itc_pte_copy(t);
     500                itc_pte_copy(&t);
    499501        } else {
    500502                /*
     
    600602       
    601603       
    602         pte_t *entry = page_mapping_find(as, va, true);
    603         if (entry) {
     604        pte_t t;
     605        bool found = page_mapping_find(as, va, true, &t);
     606        if (found) {
     607                ASSERT(t.p);
     608
    604609                /*
    605610                 * The mapping was found in the software page hash table.
    606611                 * Insert it into data translation cache.
    607612                 */
    608                 dtc_pte_copy(entry);
     613                dtc_pte_copy(&t);
    609614        } else {
    610615                if (try_memmap_io_insertion(va, istate))
     
    641646{
    642647        uintptr_t va;
    643         pte_t *t;
     648        pte_t t;
    644649        as_t *as = AS;
    645650       
     
    649654                as = AS_KERNEL;
    650655
    651         t = page_mapping_find(as, va, true);
    652         ASSERT((t) && (t->p));
    653         if ((t) && (t->p) && (t->w)) {
     656        bool found = page_mapping_find(as, va, true, &t);
     657
     658        ASSERT(found);
     659        ASSERT(t.p);
     660
     661        if (found && t.p && t.w) {
    654662                /*
    655663                 * Update the Dirty bit in page tables and reinsert
    656664                 * the mapping into DTC.
    657665                 */
    658                 t->d = true;
    659                 dtc_pte_copy(t);
     666                t.d = true;
     667                dtc_pte_copy(&t);
     668                page_mapping_update(as, va, true, &t);
    660669        } else {
    661670                as_page_fault(va, PF_ACCESS_WRITE, istate);
     
    672681{
    673682        uintptr_t va;
    674         pte_t *t;
     683        pte_t t;
    675684       
    676685        va = istate->cr_ifa;  /* faulting address */
     
    678687        ASSERT(!is_kernel_fault(va));
    679688       
    680         t = page_mapping_find(AS, va, true);
    681         ASSERT((t) && (t->p));
    682         if ((t) && (t->p) && (t->x)) {
     689        bool found = page_mapping_find(AS, va, true, &t);
     690
     691        ASSERT(found);
     692        ASSERT(t.p);
     693
     694        if (found && t.p && t.x) {
    683695                /*
    684696                 * Update the Accessed bit in page tables and reinsert
    685697                 * the mapping into ITC.
    686698                 */
    687                 t->a = true;
    688                 itc_pte_copy(t);
     699                t.a = true;
     700                itc_pte_copy(&t);
     701                page_mapping_update(AS, va, true, &t);
    689702        } else {
    690703                as_page_fault(va, PF_ACCESS_EXEC, istate);
     
    701714{
    702715        uintptr_t va;
    703         pte_t *t;
     716        pte_t t;
    704717        as_t *as = AS;
    705718       
     
    709722                as = AS_KERNEL;
    710723
    711         t = page_mapping_find(as, va, true);
    712         ASSERT((t) && (t->p));
    713         if ((t) && (t->p)) {
     724        bool found = page_mapping_find(as, va, true, &t);
     725
     726        ASSERT(found);
     727        ASSERT(t.p);
     728
     729        if (found && t.p) {
    714730                /*
    715731                 * Update the Accessed bit in page tables and reinsert
    716732                 * the mapping into DTC.
    717733                 */
    718                 t->a = true;
    719                 dtc_pte_copy(t);
     734                t.a = true;
     735                dtc_pte_copy(&t);
     736                page_mapping_update(as, va, true, &t);
    720737        } else {
    721738                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
     
    736753{
    737754        uintptr_t va;
    738         pte_t *t;
     755        pte_t t;
    739756       
    740757        va = istate->cr_ifa;  /* faulting address */
     
    745762         * Assume a write to a read-only page.
    746763         */
    747         t = page_mapping_find(AS, va, true);
    748         ASSERT((t) && (t->p));
    749         ASSERT(!t->w);
     764        bool found = page_mapping_find(AS, va, true, &t);
     765
     766        ASSERT(found);
     767        ASSERT(t.p);
     768        ASSERT(!t.w);
     769
    750770        as_page_fault(va, PF_ACCESS_WRITE, istate);
    751771}
     
    760780{
    761781        uintptr_t va;
    762         pte_t *t;
     782        pte_t t;
    763783       
    764784        va = istate->cr_ifa;  /* faulting address */
     
    766786        ASSERT(!is_kernel_fault(va));
    767787
    768         t = page_mapping_find(AS, va, true);
    769         ASSERT(t);
    770        
    771         if (t->p) {
     788        bool found = page_mapping_find(AS, va, true, &t);
     789
     790        ASSERT(found);
     791       
     792        if (t.p) {
    772793                /*
    773794                 * If the Present bit is set in page hash table, just copy it
    774795                 * and update ITC/DTC.
    775796                 */
    776                 if (t->x)
    777                         itc_pte_copy(t);
     797                if (t.x)
     798                        itc_pte_copy(&t);
    778799                else
    779                         dtc_pte_copy(t);
     800                        dtc_pte_copy(&t);
    780801        } else {
    781802                as_page_fault(va, PF_ACCESS_READ, istate);
Note: See TracChangeset for help on using the changeset viewer.