Changes in / [2a2fbc8:f126c87] in mainline


Ignore:
Location:
kernel
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/abs32le/include/arch/mm/page.h

    r2a2fbc8 rf126c87  
    115115/* Macros for querying the last level entries. */
    116116#define PTE_VALID_ARCH(p) \
    117         ((p)->soft_valid != 0)
     117        (*((uint32_t *) (p)) != 0)
    118118#define PTE_PRESENT_ARCH(p) \
    119119        ((p)->present != 0)

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

    r2a2fbc8 rf126c87  
    131131/* Macros for querying the last-level PTE entries. */
    132132#define PTE_VALID_ARCH(p) \
    133         ((p)->soft_valid != 0)
     133        (*((uint64_t *) (p)) != 0)
    134134#define PTE_PRESENT_ARCH(p) \
    135135        ((p)->present != 0)

  • kernel/arch/arm32/include/arch/mm/page_armv4.h

    r2a2fbc8 rf126c87  
    4444/* Macros for querying the last-level PTE entries. */
    4545#define PTE_VALID_ARCH(pte) \
    46         (((pte_t *) (pte))->l0.should_be_zero != 0 || PTE_PRESENT_ARCH(pte))
     46        (*((uint32_t *) (pte)) != 0)
    4747#define PTE_PRESENT_ARCH(pte) \
    4848        (((pte_t *) (pte))->l0.descriptor_type != 0)

  • kernel/arch/arm32/include/arch/mm/page_armv6.h

    r2a2fbc8 rf126c87  
    4444/* Macros for querying the last-level PTE entries. */
    4545#define PTE_VALID_ARCH(pte) \
    46         (((pte_t *) (pte))->l0.should_be_zero_0 != 0 || PTE_PRESENT_ARCH(pte))
     46        (*((uint32_t *) (pte)) != 0)
    4747#define PTE_PRESENT_ARCH(pte) \
    4848        (((pte_t *) (pte))->l0.descriptor_type != 0)

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

    r2a2fbc8 rf126c87  
    132132/* Macros for querying the last level entries. */
    133133#define PTE_VALID_ARCH(p) \
    134         ((p)->soft_valid != 0)
     134        (*((uint32_t *) (p)) != 0)
    135135#define PTE_PRESENT_ARCH(p) \
    136136        ((p)->present != 0)

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

    r2a2fbc8 rf126c87  
    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);

  • kernel/arch/mips32/include/arch/mm/page.h

    r2a2fbc8 rf126c87  
    137137
    138138/* Last-level info macros. */
    139 #define PTE_VALID_ARCH(pte)             ((pte)->soft_valid != 0)
    140 #define PTE_PRESENT_ARCH(pte)           ((pte)->p != 0)
    141 #define PTE_GET_FRAME_ARCH(pte)         ((pte)->pfn << 12)
    142 #define PTE_WRITABLE_ARCH(pte)          ((pte)->w != 0)
    143 #define PTE_EXECUTABLE_ARCH(pte)        1
     139#define PTE_VALID_ARCH(pte)                     (*((uint32_t *) (pte)) != 0)
     140#define PTE_PRESENT_ARCH(pte)                   ((pte)->p != 0)
     141#define PTE_GET_FRAME_ARCH(pte)                 ((pte)->pfn << 12)
     142#define PTE_WRITABLE_ARCH(pte)                  ((pte)->w != 0)
     143#define PTE_EXECUTABLE_ARCH(pte)                1
    144144
    145145#ifndef __ASM__

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

    r2a2fbc8 rf126c87  
    9797        entry_lo_t lo;
    9898        uintptr_t badvaddr;
    99         pte_t pte;
     99        pte_t *pte;
    100100       
    101101        badvaddr = cp0_badvaddr_read();
    102102
    103         bool found = page_mapping_find(AS, badvaddr, true, &pte);
    104         if (found && pte.p) {
     103        pte = page_mapping_find(AS, badvaddr, true);
     104        if (pte && pte->p) {
    105105                /*
    106106                 * Record access to PTE.
    107107                 */
    108                 pte.a = 1;
    109 
    110                 tlb_prepare_entry_lo(&lo, pte.g, pte.p, pte.d,
    111                     pte.cacheable, pte.pfn);
    112 
    113                 page_mapping_update(AS, badvaddr, true, &pte);
     108                pte->a = 1;
     109
     110                tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d,
     111                    pte->cacheable, pte->pfn);
    114112
    115113                /*
    … …  
    140138        tlb_index_t index;
    141139        uintptr_t badvaddr;
    142         pte_t pte;
     140        pte_t *pte;
    143141
    144142        /*
    … …  
    164162        badvaddr = cp0_badvaddr_read();
    165163
    166         bool found = page_mapping_find(AS, badvaddr, true, &pte);
    167         if (found && pte.p) {
     164        pte = page_mapping_find(AS, badvaddr, true);
     165        if (pte && pte->p) {
    168166                /*
    169167                 * Read the faulting TLB entry.
    … …  
    174172                 * Record access to PTE.
    175173                 */
    176                 pte.a = 1;
    177 
    178                 tlb_prepare_entry_lo(&lo, pte.g, pte.p, pte.d,
    179                     pte.cacheable, pte.pfn);
    180 
    181                 page_mapping_update(AS, badvaddr, true, &pte);
     174                pte->a = 1;
     175
     176                tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d,
     177                    pte->cacheable, pte->pfn);
    182178
    183179                /*
    … …  
    204200        tlb_index_t index;
    205201        uintptr_t badvaddr;
    206         pte_t pte;
     202        pte_t *pte;
    207203
    208204        badvaddr = cp0_badvaddr_read();
    … …  
    228224        }
    229225
    230         bool found = page_mapping_find(AS, badvaddr, true, &pte);
    231         if (found && pte.p && pte.w) {
     226        pte = page_mapping_find(AS, badvaddr, true);
     227        if (pte && pte->p && pte->w) {
    232228                /*
    233229                 * Read the faulting TLB entry.
    … …  
    238234                 * Record access and write to PTE.
    239235                 */
    240                 pte.a = 1;
    241                 pte.d = 1;
    242 
    243                 tlb_prepare_entry_lo(&lo, pte.g, pte.p, pte.w,
    244                     pte.cacheable, pte.pfn);
    245 
    246                 page_mapping_update(AS, badvaddr, true, &pte);
     236                pte->a = 1;
     237                pte->d = 1;
     238
     239                tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->w,
     240                    pte->cacheable, pte->pfn);
    247241
    248242                /*

  • kernel/arch/ppc32/include/arch/mm/page.h

    r2a2fbc8 rf126c87  
    140140
    141141/* Macros for querying the last-level PTEs. */
    142 #define PTE_VALID_ARCH(pte)       ((pte)->valid != 0)
     142#define PTE_VALID_ARCH(pte)       (*((uint32_t *) (pte)) != 0)
    143143#define PTE_PRESENT_ARCH(pte)     ((pte)->present != 0)
    144144#define PTE_GET_FRAME_ARCH(pte)   ((pte)->pfn << 12)

  • kernel/arch/ppc32/src/mm/pht.c

    r2a2fbc8 rf126c87  
    4949 * @param access   Access mode that caused the fault.
    5050 * @param istate   Pointer to interrupted state.
    51  * @param[out] pte Structure that will receive a copy of the found PTE.
    52  *
    53  * @return True if the mapping was found, false otherwise.
    54  *
    55  */
    56 static bool find_mapping_and_check(as_t *as, uintptr_t badvaddr, int access,
    57     istate_t *istate, pte_t *pte)
     51 *
     52 * @return PTE on success, NULL otherwise.
     53 *
     54 */
     55static pte_t *find_mapping_and_check(as_t *as, uintptr_t badvaddr, int access,
     56    istate_t *istate)
    5857{
    5958        /*
    6059         * Check if the mapping exists in page tables.
    6160         */
    62         bool found = page_mapping_find(as, badvaddr, true, pte);
    63         if (found && pte->present) {
     61        pte_t *pte = page_mapping_find(as, badvaddr, true);
     62        if ((pte) && (pte->present)) {
    6463                /*
    6564                 * Mapping found in page tables.
    6665                 * Immediately succeed.
    6766                 */
    68                 return true;
     67                return pte;
    6968        }
    7069        /*
    … …  
    7776                 * The mapping ought to be in place.
    7877                 */
    79                 found = page_mapping_find(as, badvaddr, true, pte);
    80 
    81                 ASSERT(found);
    82                 ASSERT(pte->present);
    83 
    84                 return found;
    85         }
    86 
    87         return false;
     78                pte = page_mapping_find(as, badvaddr, true);
     79                ASSERT((pte) && (pte->present));
     80                return pte;
     81        }
     82
     83        return NULL;
    8884}
    8985
    … …  
    186182                badvaddr = istate->pc;
    187183       
    188         pte_t pte;
    189         bool found = find_mapping_and_check(AS, badvaddr,
    190             PF_ACCESS_READ /* FIXME */, istate, &pte);
    191        
    192         if (found) {
     184        pte_t *pte = find_mapping_and_check(AS, badvaddr,
     185            PF_ACCESS_READ /* FIXME */, istate);
     186       
     187        if (pte) {
    193188                /* Record access to PTE */
    194                 pte.accessed = 1;
    195                 pht_insert(badvaddr, &pte);
     189                pte->accessed = 1;
     190                pht_insert(badvaddr, pte);
    196191        }
    197192}

  • kernel/arch/sparc32/include/arch/mm/page.h

    r2a2fbc8 rf126c87  
    129129/* Macros for querying the last level entries. */
    130130#define PTE_VALID_ARCH(p) \
    131         ((p)->et != PTE_ET_INVALID)
     131        (*((uint32_t *) (p)) != 0)
    132132#define PTE_PRESENT_ARCH(p) \
    133133        ((p)->et != 0)

  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r2a2fbc8 rf126c87  
    197197{
    198198        size_t index = (istate->tpc >> MMU_PAGE_WIDTH) % MMU_PAGES_PER_PAGE;
    199         pte_t t;
    200 
    201         bool found = page_mapping_find(AS, istate->tpc, true, &t);
    202         if (found && PTE_EXECUTABLE(&t)) {
     199        pte_t *t;
     200
     201        t = page_mapping_find(AS, istate->tpc, true);
     202        if (t && PTE_EXECUTABLE(t)) {
    203203                /*
    204204                 * The mapping was found in the software page hash table.
    205205                 * Insert it into ITLB.
    206206                 */
    207                 t.a = true;
    208                 itlb_pte_copy(&t, index);
     207                t->a = true;
     208                itlb_pte_copy(t, index);
    209209#ifdef CONFIG_TSB
    210                 itsb_pte_copy(&t, index);
    211 #endif
    212                 page_mapping_update(AS, istate->tpc, true, &t);
     210                itsb_pte_copy(t, index);
     211#endif
    213212        } else {
    214213                /*
    … …  
    234233        uintptr_t page_16k;
    235234        size_t index;
    236         pte_t t;
     235        pte_t *t;
    237236        as_t *as = AS;
    238237
    … …  
    254253        }
    255254
    256         bool found = page_mapping_find(as, page_16k, true, &t);
    257         if (found) {
     255        t = page_mapping_find(as, page_16k, true);
     256        if (t) {
    258257                /*
    259258                 * The mapping was found in the software page hash table.
    260259                 * Insert it into DTLB.
    261260                 */
    262                 t.a = true;
    263                 dtlb_pte_copy(&t, index, true);
     261                t->a = true;
     262                dtlb_pte_copy(t, index, true);
    264263#ifdef CONFIG_TSB
    265                 dtsb_pte_copy(&t, index, true);
    266 #endif
    267                 page_mapping_update(as, page_16k, true, &t);
     264                dtsb_pte_copy(t, index, true);
     265#endif
    268266        } else {
    269267                /*
    … …  
    285283        uintptr_t page_16k;
    286284        size_t index;
    287         pte_t t;
     285        pte_t *t;
    288286        as_t *as = AS;
    289287
    … …  
    295293                as = AS_KERNEL;
    296294
    297         bool found = page_mapping_find(as, page_16k, true, &t);
    298         if (found && PTE_WRITABLE(&t)) {
     295        t = page_mapping_find(as, page_16k, true);
     296        if (t && PTE_WRITABLE(t)) {
    299297                /*
    300298                 * The mapping was found in the software page hash table and is
    … …  
    302300                 * into DTLB.
    303301                 */
    304                 t.a = true;
    305                 t.d = true;
     302                t->a = true;
     303                t->d = true;
    306304                dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_SECONDARY,
    307305                    page_16k + index * MMU_PAGE_SIZE);
    308                 dtlb_pte_copy(&t, index, false);
     306                dtlb_pte_copy(t, index, false);
    309307#ifdef CONFIG_TSB
    310                 dtsb_pte_copy(&t, index, false);
    311 #endif
    312                 page_mapping_update(as, page_16k, true, &t);
     308                dtsb_pte_copy(t, index, false);
     309#endif
    313310        } else {
    314311                /*

  • kernel/arch/sparc64/src/mm/sun4v/tlb.c

    r2a2fbc8 rf126c87  
    211211{
    212212        uintptr_t va = ALIGN_DOWN(istate->tpc, PAGE_SIZE);
    213         pte_t t;
    214 
    215         bool found = page_mapping_find(AS, va, true, &t);
    216         if (found && PTE_EXECUTABLE(&t)) {
     213        pte_t *t;
     214
     215        t = page_mapping_find(AS, va, true);
     216
     217        if (t && PTE_EXECUTABLE(t)) {
    217218                /*
    218219                 * The mapping was found in the software page hash table.
    219220                 * Insert it into ITLB.
    220221                 */
    221                 t.a = true;
    222                 itlb_pte_copy(&t);
     222                t->a = true;
     223                itlb_pte_copy(t);
    223224#ifdef CONFIG_TSB
    224                 itsb_pte_copy(&t);
    225 #endif
    226                 page_mapping_update(AS, va, true, &t);
     225                itsb_pte_copy(t);
     226#endif
    227227        } else {
    228228                /*
    … …  
    244244void fast_data_access_mmu_miss(unsigned int tt, istate_t *istate)
    245245{
    246         pte_t t;
     246        pte_t *t;
    247247        uintptr_t va = DMISS_ADDRESS(istate->tlb_tag_access);
    248248        uint16_t ctx = DMISS_CONTEXT(istate->tlb_tag_access);
    … …  
    261261        }
    262262
    263         bool found = page_mapping_find(as, va, true, &t);
    264         if (found) {
     263        t = page_mapping_find(as, va, true);
     264        if (t) {
    265265                /*
    266266                 * The mapping was found in the software page hash table.
    267267                 * Insert it into DTLB.
    268268                 */
    269                 t.a = true;
    270                 dtlb_pte_copy(&t, true);
     269                t->a = true;
     270                dtlb_pte_copy(t, true);
    271271#ifdef CONFIG_TSB
    272                 dtsb_pte_copy(&t, true);
    273 #endif
    274                 page_mapping_update(as, va, true, &t);
     272                dtsb_pte_copy(t, true);
     273#endif
    275274        } else {
    276275                /*
    … …  
    289288void fast_data_access_protection(unsigned int tt, istate_t *istate)
    290289{
    291         pte_t t;
     290        pte_t *t;
    292291        uintptr_t va = DMISS_ADDRESS(istate->tlb_tag_access);
    293292        uint16_t ctx = DMISS_CONTEXT(istate->tlb_tag_access);
    … …  
    297296                as = AS_KERNEL;
    298297
    299         bool found = page_mapping_find(as, va, true, &t);
    300         if (found && PTE_WRITABLE(&t)) {
     298        t = page_mapping_find(as, va, true);
     299        if (t && PTE_WRITABLE(t)) {
    301300                /*
    302301                 * The mapping was found in the software page hash table and is
    … …  
    304303                 * into DTLB.
    305304                 */
    306                 t.a = true;
    307                 t.d = true;
     305                t->a = true;
     306                t->d = true;
    308307                mmu_demap_page(va, ctx, MMU_FLAG_DTLB);
    309                 dtlb_pte_copy(&t, false);
     308                dtlb_pte_copy(t, false);
    310309#ifdef CONFIG_TSB
    311                 dtsb_pte_copy(&t, false);
    312 #endif
    313                 page_mapping_update(as, va, true, &t);
     310                dtsb_pte_copy(t, false);
     311#endif
    314312        } else {
    315313                /*

  • kernel/genarch/include/genarch/mm/page_ht.h

    r2a2fbc8 rf126c87  
    4444#include <mm/page.h>
    4545#include <mm/slab.h>
     46#include <synch/mutex.h>
    4647#include <adt/hash_table.h>
    4748
    … …  
    5455
    5556/* Macros for querying page hash table PTEs. */
    56 #define PTE_VALID(pte)       ((void *) (pte) != NULL)
     57#define PTE_VALID(pte)       ((pte) != NULL)
    5758#define PTE_PRESENT(pte)     ((pte)->p != 0)
    5859#define PTE_GET_FRAME(pte)   ((pte)->frame)
    … …  
    6566
    6667extern slab_cache_t *pte_cache;
     68extern mutex_t page_ht_lock;
    6769extern hash_table_t page_ht;
    6870extern hash_table_operations_t ht_operations;

  • kernel/genarch/src/mm/as_ht.c

    r2a2fbc8 rf126c87  
    7777        if (flags & FLAG_AS_KERNEL) {
    7878                hash_table_create(&page_ht, PAGE_HT_ENTRIES, 2, &ht_operations);
     79                mutex_initialize(&page_ht_lock, MUTEX_PASSIVE);
    7980                pte_cache = slab_cache_create("pte_t", sizeof(pte_t), 0,
    8081                    NULL, NULL, SLAB_CACHE_MAGDEFERRED);
    … …  
    9899/** Lock page table.
    99100 *
    100  * Lock address space.
     101 * Lock address space and page hash table.
    101102 * Interrupts must be disabled.
    102103 *
    … …  
    109110        if (lock)
    110111                mutex_lock(&as->lock);
     112       
     113        mutex_lock(&page_ht_lock);
    111114}
    112115
    113116/** Unlock page table.
    114117 *
    115  * Unlock address space.
     118 * Unlock address space and page hash table.
    116119 * Interrupts must be disabled.
    117120 *
    … …  
    122125void ht_unlock(as_t *as, bool unlock)
    123126{
     127        mutex_unlock(&page_ht_lock);
     128       
    124129        if (unlock)
    125130                mutex_unlock(&as->lock);
    … …  
    135140bool ht_locked(as_t *as)
    136141{
    137         return mutex_locked(&as->lock);
     142        return (mutex_locked(&page_ht_lock) && mutex_locked(&as->lock));
    138143}
    139144

  • kernel/genarch/src/mm/page_ht.c

    r2a2fbc8 rf126c87  
    5959static void ht_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    6060static void ht_mapping_remove(as_t *, uintptr_t);
    61 static bool ht_mapping_find(as_t *, uintptr_t, bool, pte_t *);
    62 static void ht_mapping_update(as_t *, uintptr_t, bool, pte_t *);
     61static pte_t *ht_mapping_find(as_t *, uintptr_t, bool);
    6362static void ht_mapping_make_global(uintptr_t, size_t);
    6463
    … …  
    7170 *
    7271 */
    73 IRQ_SPINLOCK_STATIC_INITIALIZE(page_ht_lock);
     72mutex_t page_ht_lock;
    7473
    7574/** Page hash table.
    … …  
    9291        .mapping_remove = ht_mapping_remove,
    9392        .mapping_find = ht_mapping_find,
    94         .mapping_update = ht_mapping_update,
    9593        .mapping_make_global = ht_mapping_make_global
    9694};
    … …  
    193191
    194192        ASSERT(page_table_locked(as));
    195 
    196         irq_spinlock_lock(&page_ht_lock, true);
    197193       
    198194        if (!hash_table_find(&page_ht, key)) {
    … …  
    221217                hash_table_insert(&page_ht, key, &pte->link);
    222218        }
    223 
    224         irq_spinlock_unlock(&page_ht_lock, true);
    225219}
    226220
    … …  
    244238        ASSERT(page_table_locked(as));
    245239       
    246         irq_spinlock_lock(&page_ht_lock, true);
    247 
    248240        /*
    249241         * Note that removed PTE's will be freed
    … …  
    251243         */
    252244        hash_table_remove(&page_ht, key, 2);
    253 
    254         irq_spinlock_unlock(&page_ht_lock, true);
    255 }
    256 
    257 static pte_t *ht_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
     245}
     246
     247
     248/** Find mapping for virtual page in page hash table.
     249 *
     250 * @param as     Address space to which page belongs.
     251 * @param page   Virtual page.
     252 * @param nolock True if the page tables need not be locked.
     253 *
     254 * @return NULL if there is no such mapping; requested mapping otherwise.
     255 *
     256 */
     257pte_t *ht_mapping_find(as_t *as, uintptr_t page, bool nolock)
    258258{
    259259        sysarg_t key[2] = {
    … …  
    263263
    264264        ASSERT(nolock || page_table_locked(as));
    265 
     265       
    266266        link_t *cur = hash_table_find(&page_ht, key);
    267267        if (cur)
    … …  
    271271}
    272272
    273 /** Find mapping for virtual page in page hash table.
    274  *
    275  * @param as       Address space to which page belongs.
    276  * @param page     Virtual page.
    277  * @param nolock   True if the page tables need not be locked.
    278  * @param[out] pte Structure that will receive a copy of the found PTE.
    279  *
    280  * @return True if the mapping was found, false otherwise.
    281  */
    282 bool ht_mapping_find(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
    283 {
    284         irq_spinlock_lock(&page_ht_lock, true);
    285 
    286         pte_t *t = ht_mapping_find_internal(as, page, nolock);
    287         if (t)
    288                 *pte = *t;
    289 
    290         irq_spinlock_unlock(&page_ht_lock, true);
    291        
    292         return t != NULL;
    293 }
    294 
    295 /** Update mapping for virtual page in page hash table.
    296  *
    297  * @param as       Address space to which page belongs.
    298  * @param page     Virtual page.
    299  * @param nolock   True if the page tables need not be locked.
    300  * @param pte      New PTE.
    301  */
    302 void ht_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
    303 {
    304         irq_spinlock_lock(&page_ht_lock, true);
    305 
    306         pte_t *t = ht_mapping_find_internal(as, page, nolock);
    307         if (!t)
    308                 panic("Updating non-existent PTE");
    309        
    310         ASSERT(pte->as == t->as);
    311         ASSERT(pte->page == t->page);
    312         ASSERT(pte->frame == t->frame);
    313         ASSERT(pte->g == t->g);
    314         ASSERT(pte->x == t->x);
    315         ASSERT(pte->w == t->w);
    316         ASSERT(pte->k == t->k);
    317         ASSERT(pte->c == t->c);
    318         ASSERT(pte->p == t->p);
    319 
    320         t->a = pte->a;
    321         t->d = pte->d;
    322 
    323         irq_spinlock_unlock(&page_ht_lock, true);
    324 }
    325 
    326273void ht_mapping_make_global(uintptr_t base, size_t size)
    327274{

  • kernel/genarch/src/mm/page_pt.c

    r2a2fbc8 rf126c87  
    5353static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    5454static void pt_mapping_remove(as_t *, uintptr_t);
    55 static bool pt_mapping_find(as_t *, uintptr_t, bool, pte_t *pte);
    56 static void pt_mapping_update(as_t *, uintptr_t, bool, pte_t *pte);
     55static pte_t *pt_mapping_find(as_t *, uintptr_t, bool);
    5756static void pt_mapping_make_global(uintptr_t, size_t);
    5857
    … …  
    6160        .mapping_remove = pt_mapping_remove,
    6261        .mapping_find = pt_mapping_find,
    63         .mapping_update = pt_mapping_update,
    6462        .mapping_make_global = pt_mapping_make_global
    6563};
    … …  
    291289}
    292290
    293 static pte_t *pt_mapping_find_internal(as_t *as, uintptr_t page, bool nolock)
     291/** Find mapping for virtual page in hierarchical page tables.
     292 *
     293 * @param as     Address space to which page belongs.
     294 * @param page   Virtual page.
     295 * @param nolock True if the page tables need not be locked.
     296 *
     297 * @return NULL if there is no such mapping; entry from PTL3 describing
     298 *         the mapping otherwise.
     299 *
     300 */
     301pte_t *pt_mapping_find(as_t *as, uintptr_t page, bool nolock)
    294302{
    295303        ASSERT(nolock || page_table_locked(as));
    … …  
    326334       
    327335        return &ptl3[PTL3_INDEX(page)];
    328 }
    329 
    330 /** Find mapping for virtual page in hierarchical page tables.
    331  *
    332  * @param as       Address space to which page belongs.
    333  * @param page     Virtual page.
    334  * @param nolock   True if the page tables need not be locked.
    335  * @param[out] pte Structure that will receive a copy of the found PTE.
    336  *
    337  * @return True if the mapping was found, false otherwise.
    338  */
    339 bool pt_mapping_find(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
    340 {
    341         pte_t *t = pt_mapping_find_internal(as, page, nolock);
    342         if (t)
    343                 *pte = *t;
    344         return t != NULL;
    345 }
    346 
    347 /** Update mapping for virtual page in hierarchical page tables.
    348  *
    349  * @param as       Address space to which page belongs.
    350  * @param page     Virtual page.
    351  * @param nolock   True if the page tables need not be locked.
    352  * @param[in] pte  New PTE.
    353  */
    354 void pt_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
    355 {
    356         pte_t *t = pt_mapping_find_internal(as, page, nolock);
    357         if (!t)
    358                 panic("Updating non-existent PTE");     
    359 
    360         ASSERT(PTE_VALID(t) == PTE_VALID(pte));
    361         ASSERT(PTE_PRESENT(t) == PTE_PRESENT(pte));
    362         ASSERT(PTE_GET_FRAME(t) == PTE_GET_FRAME(pte));
    363         ASSERT(PTE_WRITABLE(t) == PTE_WRITABLE(pte));
    364         ASSERT(PTE_EXECUTABLE(t) == PTE_EXECUTABLE(pte));
    365 
    366         *t = *pte;
    367336}
    368337

  • kernel/generic/include/mm/page.h

    r2a2fbc8 rf126c87  
    4848        void (* mapping_insert)(as_t *, uintptr_t, uintptr_t, unsigned int);
    4949        void (* mapping_remove)(as_t *, uintptr_t);
    50         bool (* mapping_find)(as_t *, uintptr_t, bool, pte_t *);
    51         void (* mapping_update)(as_t *, uintptr_t, bool, pte_t *);
     50        pte_t *(* mapping_find)(as_t *, uintptr_t, bool);
    5251        void (* mapping_make_global)(uintptr_t, size_t);
    5352} page_mapping_operations_t;
    … …  
    6160extern void page_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    6261extern void page_mapping_remove(as_t *, uintptr_t);
    63 extern bool page_mapping_find(as_t *, uintptr_t, bool, pte_t *);
    64 extern void page_mapping_update(as_t *, uintptr_t, bool, pte_t *);
     62extern pte_t *page_mapping_find(as_t *, uintptr_t, bool);
    6563extern void page_mapping_make_global(uintptr_t, size_t);
    6664extern pte_t *page_table_create(unsigned int);

  • kernel/generic/src/ipc/ops/pagein.c

    r2a2fbc8 rf126c87  
    4747{
    4848        if (!IPC_GET_RETVAL(answer->data)) {
    49                 pte_t pte;
     49                pte_t *pte;
    5050                uintptr_t frame;
    5151
    5252                page_table_lock(AS, true);
    53                 bool found = page_mapping_find(AS, IPC_GET_ARG1(answer->data),
    54                     false, &pte);
    55                 if (found) {
    56                         frame = PTE_GET_FRAME(&pte);
     53                pte = page_mapping_find(AS, IPC_GET_ARG1(answer->data), false);
     54                if (pte) {
     55                        frame = PTE_GET_FRAME(pte);
    5756                        pfn_t pfn = ADDR2PFN(frame);
    5857                        if (find_zone(pfn, 1, 0) != (size_t) -1) {

  • kernel/generic/src/mm/as.c

    r2a2fbc8 rf126c87  
    889889               
    890890                                for (; i < node_size; i++) {
    891                                         pte_t pte;
    892                                         bool found = page_mapping_find(as,
    893                                             ptr + P2SZ(i), false, &pte);
     891                                        pte_t *pte = page_mapping_find(as,
     892                                            ptr + P2SZ(i), false);
    894893                                       
    895                                         ASSERT(found);
    896                                         ASSERT(PTE_VALID(&pte));
    897                                         ASSERT(PTE_PRESENT(&pte));
     894                                        ASSERT(pte);
     895                                        ASSERT(PTE_VALID(pte));
     896                                        ASSERT(PTE_PRESENT(pte));
    898897                                       
    899898                                        if ((area->backend) &&
    … …  
    901900                                                area->backend->frame_free(area,
    902901                                                    ptr + P2SZ(i),
    903                                                     PTE_GET_FRAME(&pte));
     902                                                    PTE_GET_FRAME(pte));
    904903                                        }
    905904                                       
    … …  
    10041003                       
    10051004                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1006                                 pte_t pte;
    1007                                 bool found = page_mapping_find(as,
    1008                                      ptr + P2SZ(size), false, &pte);
     1005                                pte_t *pte = page_mapping_find(as,
     1006                                     ptr + P2SZ(size), false);
    10091007                               
    1010                                 ASSERT(found);
    1011                                 ASSERT(PTE_VALID(&pte));
    1012                                 ASSERT(PTE_PRESENT(&pte));
     1008                                ASSERT(pte);
     1009                                ASSERT(PTE_VALID(pte));
     1010                                ASSERT(PTE_PRESENT(pte));
    10131011                               
    10141012                                if ((area->backend) &&
    … …  
    10161014                                        area->backend->frame_free(area,
    10171015                                            ptr + P2SZ(size),
    1018                                             PTE_GET_FRAME(&pte));
     1016                                            PTE_GET_FRAME(pte));
    10191017                                }
    10201018                               
    … …  
    13171315                       
    13181316                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1319                                 pte_t pte;
    1320                                 bool found = page_mapping_find(as,
    1321                                     ptr + P2SZ(size), false, &pte);
     1317                                pte_t *pte = page_mapping_find(as,
     1318                                    ptr + P2SZ(size), false);
    13221319                               
    1323                                 ASSERT(found);
    1324                                 ASSERT(PTE_VALID(&pte));
    1325                                 ASSERT(PTE_PRESENT(&pte));
     1320                                ASSERT(pte);
     1321                                ASSERT(PTE_VALID(pte));
     1322                                ASSERT(PTE_PRESENT(pte));
    13261323                               
    1327                                 old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
     1324                                old_frame[frame_idx++] = PTE_GET_FRAME(pte);
    13281325                               
    13291326                                /* Remove old mapping */
    … …  
    14551452         * we need to make sure the mapping has not been already inserted.
    14561453         */
    1457         pte_t pte;
    1458         bool found = page_mapping_find(AS, page, false, &pte);
    1459         if (found) {
    1460                 if (PTE_PRESENT(&pte)) {
    1461                         if (((access == PF_ACCESS_READ) && PTE_READABLE(&pte)) ||
    1462                             (access == PF_ACCESS_WRITE && PTE_WRITABLE(&pte)) ||
    1463                             (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(&pte))) {
     1454        pte_t *pte;
     1455        if ((pte = page_mapping_find(AS, page, false))) {
     1456                if (PTE_PRESENT(pte)) {
     1457                        if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
     1458                            (access == PF_ACCESS_WRITE && PTE_WRITABLE(pte)) ||
     1459                            (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(pte))) {
    14641460                                page_table_unlock(AS, false);
    14651461                                mutex_unlock(&area->lock);

  • kernel/generic/src/mm/backend_anon.c

    r2a2fbc8 rf126c87  
    131131                       
    132132                        for (j = 0; j < count; j++) {
    133                                 pte_t pte;
    134                                 bool found;
     133                                pte_t *pte;
    135134                       
    136135                                page_table_lock(area->as, false);
    137                                 found = page_mapping_find(area->as,
    138                                     base + P2SZ(j), false, &pte);
    139 
    140                                 ASSERT(found);
    141                                 ASSERT(PTE_VALID(&pte));
    142                                 ASSERT(PTE_PRESENT(&pte));
    143 
     136                                pte = page_mapping_find(area->as,
     137                                    base + P2SZ(j), false);
     138                                ASSERT(pte && PTE_VALID(pte) &&
     139                                    PTE_PRESENT(pte));
    144140                                btree_insert(&area->sh_info->pagemap,
    145141                                    (base + P2SZ(j)) - area->base,
    146                                     (void *) PTE_GET_FRAME(&pte), NULL);
     142                                    (void *) PTE_GET_FRAME(pte), NULL);
    147143                                page_table_unlock(area->as, false);
    148144
    149                                 pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(&pte));
     145                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
    150146                                frame_reference_add(pfn);
    151147                        }

  • kernel/generic/src/mm/backend_elf.c

    r2a2fbc8 rf126c87  
    184184                       
    185185                        for (j = 0; j < count; j++) {
    186                                 pte_t pte;
    187                                 bool found;
     186                                pte_t *pte;
    188187                       
    189188                                /*
    … …  
    197196                               
    198197                                page_table_lock(area->as, false);
    199                                 found = page_mapping_find(area->as,
    200                                     base + P2SZ(j), false, &pte);
    201 
    202                                 ASSERT(found);
    203                                 ASSERT(PTE_VALID(&pte));
    204                                 ASSERT(PTE_PRESENT(&pte));
    205 
     198                                pte = page_mapping_find(area->as,
     199                                    base + P2SZ(j), false);
     200                                ASSERT(pte && PTE_VALID(pte) &&
     201                                    PTE_PRESENT(pte));
    206202                                btree_insert(&area->sh_info->pagemap,
    207203                                    (base + P2SZ(j)) - area->base,
    208                                     (void *) PTE_GET_FRAME(&pte), NULL);
     204                                    (void *) PTE_GET_FRAME(pte), NULL);
    209205                                page_table_unlock(area->as, false);
    210206
    211                                 pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(&pte));
     207                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
    212208                                frame_reference_add(pfn);
    213209                        }
    … …  
    339335                        dirty = true;
    340336                } else {
    341                         pte_t pte;
    342                         bool found;
    343 
    344                         found = page_mapping_find(AS_KERNEL,
    345                             base + i * FRAME_SIZE, true, &pte);
    346 
    347                         ASSERT(found);
    348                         ASSERT(PTE_PRESENT(&pte));
    349 
    350                         frame = PTE_GET_FRAME(&pte);
     337                        pte_t *pte = page_mapping_find(AS_KERNEL,
     338                            base + i * FRAME_SIZE, true);
     339
     340                        ASSERT(pte);
     341                        ASSERT(PTE_PRESENT(pte));
     342
     343                        frame = PTE_GET_FRAME(pte);
    351344                }       
    352345        } else if (upage >= start_anon) {

  • kernel/generic/src/mm/page.c

    r2a2fbc8 rf126c87  
    137137/** Find mapping for virtual page.
    138138 *
    139  * @param as       Address space to which page belongs.
    140  * @param page     Virtual page.
    141  * @param nolock   True if the page tables need not be locked.
    142  * @param[out] pte Structure that will receive a copy of the found PTE.
    143  *
    144  * @return True if the mapping was found, false otherwise.
    145  */
    146 NO_TRACE bool page_mapping_find(as_t *as, uintptr_t page, bool nolock,
    147     pte_t *pte)
     139 * @param as     Address space to which page belongs.
     140 * @param page   Virtual page.
     141 * @param nolock True if the page tables need not be locked.
     142 *
     143 * @return NULL if there is no such mapping; requested mapping
     144 *         otherwise.
     145 *
     146 */
     147NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
    148148{
    149149        ASSERT(nolock || page_table_locked(as));
    … …  
    153153       
    154154        return page_mapping_operations->mapping_find(as,
    155             ALIGN_DOWN(page, PAGE_SIZE), nolock, pte);
    156 }
    157 
    158 /** Update mapping for virtual page.
    159  *
    160  * Use only to update accessed and modified/dirty bits.
    161  *
    162  * @param as       Address space to which page belongs.
    163  * @param page     Virtual page.
    164  * @param nolock   True if the page tables need not be locked.
    165  * @param pte      New PTE.
    166  */
    167 NO_TRACE void page_mapping_update(as_t *as, uintptr_t page, bool nolock,
    168     pte_t *pte)
    169 {
    170         ASSERT(nolock || page_table_locked(as));
    171        
    172         ASSERT(page_mapping_operations);
    173         ASSERT(page_mapping_operations->mapping_find);
    174        
    175         page_mapping_operations->mapping_update(as,
    176             ALIGN_DOWN(page, PAGE_SIZE), nolock, pte);
     155            ALIGN_DOWN(page, PAGE_SIZE), nolock);
    177156}
    178157
    … …  
    194173        page_table_lock(AS, true);
    195174       
    196         pte_t pte;
    197         bool found = page_mapping_find(AS, virt, false, &pte);
    198         if (!found || !PTE_VALID(&pte) || !PTE_PRESENT(&pte)) {
     175        pte_t *pte = page_mapping_find(AS, virt, false);
     176        if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
    199177                page_table_unlock(AS, true);
    200178                return ENOENT;
    201179        }
    202180       
    203         *phys = PTE_GET_FRAME(&pte) +
     181        *phys = PTE_GET_FRAME(pte) +
    204182            (virt - ALIGN_DOWN(virt, PAGE_SIZE));
    205183       

  • kernel/generic/src/synch/futex.c

    r2a2fbc8 rf126c87  
    291291        spinlock_lock(&futex_ht_lock);
    292292
    293         bool success = false;
    294 
    295         pte_t t;
    296         bool found;
    297 
    298         found = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), true, &t);
    299         if (found && PTE_VALID(&t) && PTE_PRESENT(&t)) {
    300                 success = true;
    301                 *paddr = PTE_GET_FRAME(&t) +
    302                     (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
     293        bool found = false;
     294        pte_t *t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), true);
     295       
     296        if (t && PTE_VALID(t) && PTE_PRESENT(t)) {
     297                found = true;
     298                *paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
    303299        }
    304300       
    … …  
    306302        page_table_unlock(AS, false);
    307303       
    308         return success;
     304        return found;
    309305}
    310306
Note: See TracChangeset for help on using the changeset viewer.