Ignore:
File:
1 edited

Legend:

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

    r346b12a2 r9928240  
    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         bool found = page_mapping_find(AS, va, true, &t);
    493         if (found) {
     492        t = page_mapping_find(AS, va, true);
     493        if (t) {
    494494                /*
    495495                 * The mapping was found in software page hash table.
    496496                 * Insert it into data translation cache.
    497497                 */
    498                 itc_pte_copy(&t);
     498                itc_pte_copy(t);
    499499        } else {
    500500                /*
     
    600600       
    601601       
    602         pte_t t;
    603         bool found = page_mapping_find(as, va, true, &t);
    604         if (found) {
     602        pte_t *entry = page_mapping_find(as, va, true);
     603        if (entry) {
    605604                /*
    606605                 * The mapping was found in the software page hash table.
    607606                 * Insert it into data translation cache.
    608607                 */
    609                 dtc_pte_copy(&t);
     608                dtc_pte_copy(entry);
    610609        } else {
    611610                if (try_memmap_io_insertion(va, istate))
     
    642641{
    643642        uintptr_t va;
    644         pte_t t;
     643        pte_t *t;
    645644        as_t *as = AS;
    646645       
     
    650649                as = AS_KERNEL;
    651650
    652         bool found = page_mapping_find(as, va, true, &t);
    653 
    654         ASSERT(found);
    655         ASSERT(t.p);
    656 
    657         if (found && t.p && t.w) {
     651        t = page_mapping_find(as, va, true);
     652        ASSERT((t) && (t->p));
     653        if ((t) && (t->p) && (t->w)) {
    658654                /*
    659655                 * Update the Dirty bit in page tables and reinsert
    660656                 * the mapping into DTC.
    661657                 */
    662                 t.d = true;
    663                 dtc_pte_copy(&t);
    664                 page_mapping_update(as, va, true, &t);
     658                t->d = true;
     659                dtc_pte_copy(t);
    665660        } else {
    666661                as_page_fault(va, PF_ACCESS_WRITE, istate);
     
    677672{
    678673        uintptr_t va;
    679         pte_t t;
     674        pte_t *t;
    680675       
    681676        va = istate->cr_ifa;  /* faulting address */
     
    683678        ASSERT(!is_kernel_fault(va));
    684679       
    685         bool found = page_mapping_find(AS, va, true, &t);
    686 
    687         ASSERT(found);
    688         ASSERT(t.p);
    689 
    690         if (found && t.p && t.x) {
     680        t = page_mapping_find(AS, va, true);
     681        ASSERT((t) && (t->p));
     682        if ((t) && (t->p) && (t->x)) {
    691683                /*
    692684                 * Update the Accessed bit in page tables and reinsert
    693685                 * the mapping into ITC.
    694686                 */
    695                 t.a = true;
    696                 itc_pte_copy(&t);
    697                 page_mapping_update(AS, va, true, &t);
     687                t->a = true;
     688                itc_pte_copy(t);
    698689        } else {
    699690                as_page_fault(va, PF_ACCESS_EXEC, istate);
     
    710701{
    711702        uintptr_t va;
    712         pte_t t;
     703        pte_t *t;
    713704        as_t *as = AS;
    714705       
     
    718709                as = AS_KERNEL;
    719710
    720         bool found = page_mapping_find(as, va, true, &t);
    721 
    722         ASSERT(found);
    723         ASSERT(t.p);
    724 
    725         if (found && t.p) {
     711        t = page_mapping_find(as, va, true);
     712        ASSERT((t) && (t->p));
     713        if ((t) && (t->p)) {
    726714                /*
    727715                 * Update the Accessed bit in page tables and reinsert
    728716                 * the mapping into DTC.
    729717                 */
    730                 t.a = true;
    731                 dtc_pte_copy(&t);
    732                 page_mapping_update(as, va, true, &t);
     718                t->a = true;
     719                dtc_pte_copy(t);
    733720        } else {
    734721                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
     
    749736{
    750737        uintptr_t va;
    751         pte_t t;
     738        pte_t *t;
    752739       
    753740        va = istate->cr_ifa;  /* faulting address */
     
    758745         * Assume a write to a read-only page.
    759746         */
    760         bool found = page_mapping_find(AS, va, true, &t);
    761 
    762         ASSERT(found);
    763         ASSERT(t.p);
    764         ASSERT(!t.w);
    765 
     747        t = page_mapping_find(AS, va, true);
     748        ASSERT((t) && (t->p));
     749        ASSERT(!t->w);
    766750        as_page_fault(va, PF_ACCESS_WRITE, istate);
    767751}
     
    776760{
    777761        uintptr_t va;
    778         pte_t t;
     762        pte_t *t;
    779763       
    780764        va = istate->cr_ifa;  /* faulting address */
     
    782766        ASSERT(!is_kernel_fault(va));
    783767
    784         bool found = page_mapping_find(AS, va, true, &t);
    785 
    786         ASSERT(found);
    787        
    788         if (t.p) {
     768        t = page_mapping_find(AS, va, true);
     769        ASSERT(t);
     770       
     771        if (t->p) {
    789772                /*
    790773                 * If the Present bit is set in page hash table, just copy it
    791774                 * and update ITC/DTC.
    792775                 */
    793                 if (t.x)
    794                         itc_pte_copy(&t);
     776                if (t->x)
     777                        itc_pte_copy(t);
    795778                else
    796                         dtc_pte_copy(&t);
     779                        dtc_pte_copy(t);
    797780        } else {
    798781                as_page_fault(va, PF_ACCESS_READ, istate);
Note: See TracChangeset for help on using the changeset viewer.