Changeset 2c2d54a in mainline for kernel/arch


Ignore:
Timestamp:
2016-09-02T17:58:05Z (9 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4c3602c4
Parents:
4bf0926e (diff), 3233adb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~jakub/helenos/pager

Location:
kernel/arch
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

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

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

    r4bf0926e r2c2d54a  
    151151/* Macros for querying the last-level PTE entries. */
    152152#define PTE_VALID_ARCH(p) \
    153         (*((uint64_t *) (p)) != 0)
     153        ((p)->soft_valid != 0)
    154154#define PTE_PRESENT_ARCH(p) \
    155155        ((p)->present != 0)

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

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

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

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

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

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

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

    r4bf0926e r2c2d54a  
    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) {
    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 *entry = page_mapping_find(as, va, true);
    603         if (entry) {
     602        pte_t t;
     603        bool found = page_mapping_find(as, va, true, &t);
     604        if (found) {
    604605                /*
    605606                 * The mapping was found in the software page hash table.
    606607                 * Insert it into data translation cache.
    607608                 */
    608                 dtc_pte_copy(entry);
     609                dtc_pte_copy(&t);
    609610        } else {
    610611                if (try_memmap_io_insertion(va, istate))
    … …  
    641642{
    642643        uintptr_t va;
    643         pte_t *t;
     644        pte_t t;
    644645        as_t *as = AS;
    645646       
    … …  
    649650                as = AS_KERNEL;
    650651
    651         t = page_mapping_find(as, va, true);
    652         ASSERT((t) && (t->p));
    653         if ((t) && (t->p) && (t->w)) {
     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) {
    654658                /*
    655659                 * Update the Dirty bit in page tables and reinsert
    656660                 * the mapping into DTC.
    657661                 */
    658                 t->d = true;
    659                 dtc_pte_copy(t);
     662                t.d = true;
     663                dtc_pte_copy(&t);
     664                page_mapping_update(as, va, true, &t);
    660665        } else {
    661666                as_page_fault(va, PF_ACCESS_WRITE, istate);
    … …  
    672677{
    673678        uintptr_t va;
    674         pte_t *t;
     679        pte_t t;
    675680       
    676681        va = istate->cr_ifa;  /* faulting address */
    … …  
    678683        ASSERT(!is_kernel_fault(va));
    679684       
    680         t = page_mapping_find(AS, va, true);
    681         ASSERT((t) && (t->p));
    682         if ((t) && (t->p) && (t->x)) {
     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) {
    683691                /*
    684692                 * Update the Accessed bit in page tables and reinsert
    685693                 * the mapping into ITC.
    686694                 */
    687                 t->a = true;
    688                 itc_pte_copy(t);
     695                t.a = true;
     696                itc_pte_copy(&t);
     697                page_mapping_update(AS, va, true, &t);
    689698        } else {
    690699                as_page_fault(va, PF_ACCESS_EXEC, istate);
    … …  
    701710{
    702711        uintptr_t va;
    703         pte_t *t;
     712        pte_t t;
    704713        as_t *as = AS;
    705714       
    … …  
    709718                as = AS_KERNEL;
    710719
    711         t = page_mapping_find(as, va, true);
    712         ASSERT((t) && (t->p));
    713         if ((t) && (t->p)) {
     720        bool found = page_mapping_find(as, va, true, &t);
     721
     722        ASSERT(found);
     723        ASSERT(t.p);
     724
     725        if (found && t.p) {
    714726                /*
    715727                 * Update the Accessed bit in page tables and reinsert
    716728                 * the mapping into DTC.
    717729                 */
    718                 t->a = true;
    719                 dtc_pte_copy(t);
     730                t.a = true;
     731                dtc_pte_copy(&t);
     732                page_mapping_update(as, va, true, &t);
    720733        } else {
    721734                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    … …  
    736749{
    737750        uintptr_t va;
    738         pte_t *t;
     751        pte_t t;
    739752       
    740753        va = istate->cr_ifa;  /* faulting address */
    … …  
    745758         * Assume a write to a read-only page.
    746759         */
    747         t = page_mapping_find(AS, va, true);
    748         ASSERT((t) && (t->p));
    749         ASSERT(!t->w);
     760        bool found = page_mapping_find(AS, va, true, &t);
     761
     762        ASSERT(found);
     763        ASSERT(t.p);
     764        ASSERT(!t.w);
     765
    750766        as_page_fault(va, PF_ACCESS_WRITE, istate);
    751767}
    … …  
    760776{
    761777        uintptr_t va;
    762         pte_t *t;
     778        pte_t t;
    763779       
    764780        va = istate->cr_ifa;  /* faulting address */
    … …  
    766782        ASSERT(!is_kernel_fault(va));
    767783
    768         t = page_mapping_find(AS, va, true);
    769         ASSERT(t);
    770        
    771         if (t->p) {
     784        bool found = page_mapping_find(AS, va, true, &t);
     785
     786        ASSERT(found);
     787       
     788        if (t.p) {
    772789                /*
    773790                 * If the Present bit is set in page hash table, just copy it
    774791                 * and update ITC/DTC.
    775792                 */
    776                 if (t->x)
    777                         itc_pte_copy(t);
     793                if (t.x)
     794                        itc_pte_copy(&t);
    778795                else
    779                         dtc_pte_copy(t);
     796                        dtc_pte_copy(&t);
    780797        } else {
    781798                as_page_fault(va, PF_ACCESS_READ, istate);

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

    r4bf0926e r2c2d54a  
    137137
    138138/* Last-level info macros. */
    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
     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
    144144
    145145#ifndef __ASM__

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

    r4bf0926e r2c2d54a  
    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         pte = page_mapping_find(AS, badvaddr, true);
    104         if (pte && pte->p) {
     103        bool found = page_mapping_find(AS, badvaddr, true, &pte);
     104        if (found && 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);
     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);
    112114
    113115                /*
    … …  
    138140        tlb_index_t index;
    139141        uintptr_t badvaddr;
    140         pte_t *pte;
     142        pte_t pte;
    141143
    142144        /*
    … …  
    162164        badvaddr = cp0_badvaddr_read();
    163165
    164         pte = page_mapping_find(AS, badvaddr, true);
    165         if (pte && pte->p) {
     166        bool found = page_mapping_find(AS, badvaddr, true, &pte);
     167        if (found && pte.p) {
    166168                /*
    167169                 * Read the faulting TLB entry.
    … …  
    172174                 * Record access to PTE.
    173175                 */
    174                 pte->a = 1;
    175 
    176                 tlb_prepare_entry_lo(&lo, pte->g, pte->p, pte->d,
    177                     pte->cacheable, pte->pfn);
     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);
    178182
    179183                /*
    … …  
    200204        tlb_index_t index;
    201205        uintptr_t badvaddr;
    202         pte_t *pte;
     206        pte_t pte;
    203207
    204208        badvaddr = cp0_badvaddr_read();
    … …  
    224228        }
    225229
    226         pte = page_mapping_find(AS, badvaddr, true);
    227         if (pte && pte->p && pte->w) {
     230        bool found = page_mapping_find(AS, badvaddr, true, &pte);
     231        if (found && pte.p && pte.w) {
    228232                /*
    229233                 * Read the faulting TLB entry.
    … …  
    234238                 * Record access and write to PTE.
    235239                 */
    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);
     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);
    241247
    242248                /*

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

    r4bf0926e r2c2d54a  
    140140
    141141/* Macros for querying the last-level PTEs. */
    142 #define PTE_VALID_ARCH(pte)       (*((uint32_t *) (pte)) != 0)
     142#define PTE_VALID_ARCH(pte)       ((pte)->valid != 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

    r4bf0926e r2c2d54a  
    4949 * @param access   Access mode that caused the fault.
    5050 * @param istate   Pointer to interrupted state.
    51  *
    52  * @return PTE on success, NULL otherwise.
    53  *
    54  */
    55 static pte_t *find_mapping_and_check(as_t *as, uintptr_t badvaddr, int access,
    56     istate_t *istate)
     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 */
     56static bool find_mapping_and_check(as_t *as, uintptr_t badvaddr, int access,
     57    istate_t *istate, pte_t *pte)
    5758{
    5859        /*
    5960         * Check if the mapping exists in page tables.
    6061         */
    61         pte_t *pte = page_mapping_find(as, badvaddr, true);
    62         if ((pte) && (pte->present)) {
     62        bool found = page_mapping_find(as, badvaddr, true, pte);
     63        if (found && pte->present) {
    6364                /*
    6465                 * Mapping found in page tables.
    6566                 * Immediately succeed.
    6667                 */
    67                 return pte;
     68                return true;
    6869        }
    6970        /*
    … …  
    7677                 * The mapping ought to be in place.
    7778                 */
    78                 pte = page_mapping_find(as, badvaddr, true);
    79                 ASSERT((pte) && (pte->present));
    80                 return pte;
    81         }
    82 
    83         return NULL;
     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;
    8488}
    8589
    … …  
    182186                badvaddr = istate->pc;
    183187       
    184         pte_t *pte = find_mapping_and_check(AS, badvaddr,
    185             PF_ACCESS_READ /* FIXME */, istate);
    186        
    187         if (pte) {
     188        pte_t pte;
     189        bool found = find_mapping_and_check(AS, badvaddr,
     190            PF_ACCESS_READ /* FIXME */, istate, &pte);
     191       
     192        if (found) {
    188193                /* Record access to PTE */
    189                 pte->accessed = 1;
    190                 pht_insert(badvaddr, pte);
     194                pte.accessed = 1;
     195                pht_insert(badvaddr, &pte);
    191196        }
    192197}

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

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

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

    r4bf0926e r2c2d54a  
    197197{
    198198        size_t index = (istate->tpc >> MMU_PAGE_WIDTH) % MMU_PAGES_PER_PAGE;
    199         pte_t *t;
    200 
    201         t = page_mapping_find(AS, istate->tpc, true);
    202         if (t && PTE_EXECUTABLE(t)) {
     199        pte_t t;
     200
     201        bool found = page_mapping_find(AS, istate->tpc, true, &t);
     202        if (found && 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
     210                itsb_pte_copy(&t, index);
     211#endif
     212                page_mapping_update(AS, istate->tpc, true, &t);
    212213        } else {
    213214                /*
    … …  
    233234        uintptr_t page_16k;
    234235        size_t index;
    235         pte_t *t;
     236        pte_t t;
    236237        as_t *as = AS;
    237238
    … …  
    253254        }
    254255
    255         t = page_mapping_find(as, page_16k, true);
    256         if (t) {
     256        bool found = page_mapping_find(as, page_16k, true, &t);
     257        if (found) {
    257258                /*
    258259                 * The mapping was found in the software page hash table.
    259260                 * Insert it into DTLB.
    260261                 */
    261                 t->a = true;
    262                 dtlb_pte_copy(t, index, true);
     262                t.a = true;
     263                dtlb_pte_copy(&t, index, true);
    263264#ifdef CONFIG_TSB
    264                 dtsb_pte_copy(t, index, true);
    265 #endif
     265                dtsb_pte_copy(&t, index, true);
     266#endif
     267                page_mapping_update(as, page_16k, true, &t);
    266268        } else {
    267269                /*
    … …  
    283285        uintptr_t page_16k;
    284286        size_t index;
    285         pte_t *t;
     287        pte_t t;
    286288        as_t *as = AS;
    287289
    … …  
    293295                as = AS_KERNEL;
    294296
    295         t = page_mapping_find(as, page_16k, true);
    296         if (t && PTE_WRITABLE(t)) {
     297        bool found = page_mapping_find(as, page_16k, true, &t);
     298        if (found && PTE_WRITABLE(&t)) {
    297299                /*
    298300                 * The mapping was found in the software page hash table and is
    … …  
    300302                 * into DTLB.
    301303                 */
    302                 t->a = true;
    303                 t->d = true;
     304                t.a = true;
     305                t.d = true;
    304306                dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_SECONDARY,
    305307                    page_16k + index * MMU_PAGE_SIZE);
    306                 dtlb_pte_copy(t, index, false);
     308                dtlb_pte_copy(&t, index, false);
    307309#ifdef CONFIG_TSB
    308                 dtsb_pte_copy(t, index, false);
    309 #endif
     310                dtsb_pte_copy(&t, index, false);
     311#endif
     312                page_mapping_update(as, page_16k, true, &t);
    310313        } else {
    311314                /*

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

    r4bf0926e r2c2d54a  
    211211{
    212212        uintptr_t va = ALIGN_DOWN(istate->tpc, PAGE_SIZE);
    213         pte_t *t;
    214 
    215         t = page_mapping_find(AS, va, true);
    216 
    217         if (t && PTE_EXECUTABLE(t)) {
     213        pte_t t;
     214
     215        bool found = page_mapping_find(AS, va, true, &t);
     216        if (found && PTE_EXECUTABLE(&t)) {
    218217                /*
    219218                 * The mapping was found in the software page hash table.
    220219                 * Insert it into ITLB.
    221220                 */
    222                 t->a = true;
    223                 itlb_pte_copy(t);
     221                t.a = true;
     222                itlb_pte_copy(&t);
    224223#ifdef CONFIG_TSB
    225                 itsb_pte_copy(t);
    226 #endif
     224                itsb_pte_copy(&t);
     225#endif
     226                page_mapping_update(AS, va, true, &t);
    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         t = page_mapping_find(as, va, true);
    264         if (t) {
     263        bool found = page_mapping_find(as, va, true, &t);
     264        if (found) {
    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
     272                dtsb_pte_copy(&t, true);
     273#endif
     274                page_mapping_update(as, va, true, &t);
    274275        } else {
    275276                /*
    … …  
    288289void fast_data_access_protection(unsigned int tt, istate_t *istate)
    289290{
    290         pte_t *t;
     291        pte_t t;
    291292        uintptr_t va = DMISS_ADDRESS(istate->tlb_tag_access);
    292293        uint16_t ctx = DMISS_CONTEXT(istate->tlb_tag_access);
    … …  
    296297                as = AS_KERNEL;
    297298
    298         t = page_mapping_find(as, va, true);
    299         if (t && PTE_WRITABLE(t)) {
     299        bool found = page_mapping_find(as, va, true, &t);
     300        if (found && PTE_WRITABLE(&t)) {
    300301                /*
    301302                 * The mapping was found in the software page hash table and is
    … …  
    303304                 * into DTLB.
    304305                 */
    305                 t->a = true;
    306                 t->d = true;
     306                t.a = true;
     307                t.d = true;
    307308                mmu_demap_page(va, ctx, MMU_FLAG_DTLB);
    308                 dtlb_pte_copy(t, false);
     309                dtlb_pte_copy(&t, false);
    309310#ifdef CONFIG_TSB
    310                 dtsb_pte_copy(t, false);
    311 #endif
     311                dtsb_pte_copy(&t, false);
     312#endif
     313                page_mapping_update(as, va, true, &t);
    312314        } else {
    313315                /*
Note: See TracChangeset for help on using the changeset viewer.