Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 9aed144 in mainline


Ignore:
Timestamp:
2011-11-25T23:35:22Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
1c01e6c
Parents:
50177dcd
Message:

Finish transition to lock-free page_mapping_find() in TLB miss handlers.

  • Simply drop the calls to page_table_lock/unlock() in ia64 and sparc64 TLB miss handlers.

As for why this is possible:

  • page_mapping_find() cannot race with page_table_remove() because page_mapping_find() is called only when interrupts are disabled, which prevents TLB shootdown from starting, which in turn prevents page_table_remove() from running
  • page_mapping_insert() will not negatively interfere with page_mapping_find() because page_mapping_insert() adds a fully initialized pte_t to the end of the hash bucket
Location:
kernel/arch
Files:
3 edited

Legend:

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

    r50177dcd r9aed144  
    480480        va = istate->cr_ifa; /* faulting address */
    481481       
    482         page_table_lock(AS, true);
    483482        t = page_mapping_find(AS, va, true);
    484483        if (t) {
     
    488487                 */
    489488                itc_pte_copy(t);
    490                 page_table_unlock(AS, true);
    491489        } else {
    492490                /*
    493491                 * Forward the page fault to address space page fault handler.
    494492                 */
    495                 page_table_unlock(AS, true);
    496493                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    497494                        fault_if_from_uspace(istate, "Page fault at %p.",
     
    598595       
    599596       
    600         page_table_lock(AS, true);
    601597        pte_t *entry = page_mapping_find(AS, va, true);
    602598        if (entry) {
     
    606602                 */
    607603                dtc_pte_copy(entry);
    608                 page_table_unlock(AS, true);
    609604        } else {
    610                 page_table_unlock(AS, true);
    611605                if (try_memmap_io_insertion(va, istate))
    612606                        return;
     
    650644        va = istate->cr_ifa;  /* faulting address */
    651645       
    652         page_table_lock(AS, true);
    653646        t = page_mapping_find(AS, va, true);
    654647        ASSERT((t) && (t->p));
     
    667660                }
    668661        }
    669         page_table_unlock(AS, true);
    670662}
    671663
     
    683675        va = istate->cr_ifa;  /* faulting address */
    684676       
    685         page_table_lock(AS, true);
    686677        t = page_mapping_find(AS, va, true);
    687678        ASSERT((t) && (t->p));
     
    700691                }
    701692        }
    702         page_table_unlock(AS, true);
    703693}
    704694
     
    716706        va = istate->cr_ifa;  /* faulting address */
    717707       
    718         page_table_lock(AS, true);
    719708        t = page_mapping_find(AS, va, true);
    720709        ASSERT((t) && (t->p));
     
    733722                }
    734723        }
    735         page_table_unlock(AS, true);
    736724}
    737725
     
    752740         * Assume a write to a read-only page.
    753741         */
    754         page_table_lock(AS, true);
    755742        t = page_mapping_find(AS, va, true);
    756743        ASSERT((t) && (t->p));
     
    761748                panic_memtrap(istate, PF_ACCESS_WRITE, va, NULL);
    762749        }
    763         page_table_unlock(AS, true);
    764750}
    765751
     
    777763        va = istate->cr_ifa;  /* faulting address */
    778764       
    779         page_table_lock(AS, true);
    780765        t = page_mapping_find(AS, va, true);
    781766        ASSERT(t);
     
    790775                else
    791776                        dtc_pte_copy(t);
    792                 page_table_unlock(AS, true);
    793777        } else {
    794                 page_table_unlock(AS, true);
    795778                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    796779                        fault_if_from_uspace(istate, "Page fault at %p.",
  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r50177dcd r9aed144  
    206206        pte_t *t;
    207207
    208         page_table_lock(AS, true);
    209208        t = page_mapping_find(AS, page_16k, true);
    210209        if (t && PTE_EXECUTABLE(t)) {
     
    218217                itsb_pte_copy(t, index);
    219218#endif
    220                 page_table_unlock(AS, true);
    221219        } else {
    222220                /*
     
    224222                 * handler.
    225223                 */
    226                 page_table_unlock(AS, true);
    227224                if (as_page_fault(page_16k, PF_ACCESS_EXEC, istate) ==
    228225                    AS_PF_FAULT) {
     
    274271        }
    275272
    276         page_table_lock(AS, true);
    277273        t = page_mapping_find(AS, page_16k, true);
    278274        if (t) {
     
    286282                dtsb_pte_copy(t, index, true);
    287283#endif
    288                 page_table_unlock(AS, true);
    289284        } else {
    290285                /*
     
    292287                 * handler.
    293288                 */             
    294                 page_table_unlock(AS, true);
    295289                if (as_page_fault(page_16k, PF_ACCESS_READ, istate) ==
    296290                    AS_PF_FAULT) {
     
    318312        index = tag.vpn % MMU_PAGES_PER_PAGE;   /* 16K-page emulation */
    319313
    320         page_table_lock(AS, true);
    321314        t = page_mapping_find(AS, page_16k, true);
    322315        if (t && PTE_WRITABLE(t)) {
     
    334327                dtsb_pte_copy(t, index, false);
    335328#endif
    336                 page_table_unlock(AS, true);
    337329        } else {
    338330                /*
     
    340332                 * handler.
    341333                 */             
    342                 page_table_unlock(AS, true);
    343334                if (as_page_fault(page_16k, PF_ACCESS_WRITE, istate) ==
    344335                    AS_PF_FAULT) {
  • kernel/arch/sparc64/src/mm/sun4v/tlb.c

    r50177dcd r9aed144  
    218218        pte_t *t;
    219219
    220         page_table_lock(AS, true);
    221220        t = page_mapping_find(AS, va, true);
    222221
     
    231230                itsb_pte_copy(t);
    232231#endif
    233                 page_table_unlock(AS, true);
    234232        } else {
    235233                /*
     
    237235                 * handler.
    238236                 */
    239                 page_table_unlock(AS, true);
    240237                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    241238                        do_fast_instruction_access_mmu_miss_fault(istate,
     
    274271        }
    275272
    276         page_table_lock(AS, true);
    277273        t = page_mapping_find(AS, va, true);
    278274        if (t) {
     
    286282                dtsb_pte_copy(t, true);
    287283#endif
    288                 page_table_unlock(AS, true);
    289284        } else {
    290285                /*
     
    292287                 * handler.
    293288                 */             
    294                 page_table_unlock(AS, true);
    295289                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    296290                        do_fast_data_access_mmu_miss_fault(istate, page_and_ctx,
     
    316310        uint16_t ctx = DMISS_CONTEXT(page_and_ctx);
    317311
    318         page_table_lock(AS, true);
    319312        t = page_mapping_find(AS, va, true);
    320313        if (t && PTE_WRITABLE(t)) {
     
    331324                dtsb_pte_copy(t, false);
    332325#endif
    333                 page_table_unlock(AS, true);
    334326        } else {
    335327                /*
     
    337329                 * handler.
    338330                 */             
    339                 page_table_unlock(AS, true);
    340331                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    341332                        do_fast_data_access_protection_fault(istate, page_and_ctx,
Note: See TracChangeset for help on using the changeset viewer.