Changes in / [eaeb056:9ea8fdb4] in mainline


Ignore:
Location:
kernel
Files:
14 edited

Legend:

Unmodified
Added
Removed

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

    reaeb056 r9ea8fdb4  
    481481       
    482482        page_table_lock(AS, true);
    483         t = page_mapping_find(AS, va, true);
     483        t = page_mapping_find(AS, va);
    484484        if (t) {
    485485                /*
    … …  
    599599       
    600600        page_table_lock(AS, true);
    601         pte_t *entry = page_mapping_find(AS, va, true);
     601        pte_t *entry = page_mapping_find(AS, va);
    602602        if (entry) {
    603603                /*
    … …  
    651651       
    652652        page_table_lock(AS, true);
    653         t = page_mapping_find(AS, va, true);
     653        t = page_mapping_find(AS, va);
    654654        ASSERT((t) && (t->p));
    655655        if ((t) && (t->p) && (t->w)) {
    … …  
    684684       
    685685        page_table_lock(AS, true);
    686         t = page_mapping_find(AS, va, true);
     686        t = page_mapping_find(AS, va);
    687687        ASSERT((t) && (t->p));
    688688        if ((t) && (t->p) && (t->x)) {
    … …  
    717717       
    718718        page_table_lock(AS, true);
    719         t = page_mapping_find(AS, va, true);
     719        t = page_mapping_find(AS, va);
    720720        ASSERT((t) && (t->p));
    721721        if ((t) && (t->p)) {
    … …  
    753753         */
    754754        page_table_lock(AS, true);
    755         t = page_mapping_find(AS, va, true);
     755        t = page_mapping_find(AS, va);
    756756        ASSERT((t) && (t->p));
    757757        ASSERT(!t->w);
    … …  
    778778       
    779779        page_table_lock(AS, true);
    780         t = page_mapping_find(AS, va, true);
     780        t = page_mapping_find(AS, va);
    781781        ASSERT(t);
    782782       

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

    reaeb056 r9ea8fdb4  
    100100        mutex_unlock(&AS->lock);
    101101       
     102        page_table_lock(AS, true);
     103       
    102104        pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
    103105        if (!pte) {
    … …  
    111113                         * or copy_to_uspace().
    112114                         */
     115                        page_table_unlock(AS, true);
    113116                        return;
    114117                default:
    … …  
    141144        tlbwr();
    142145
     146        page_table_unlock(AS, true);
    143147        return;
    144148       
    145149fail:
     150        page_table_unlock(AS, true);
    146151        tlb_refill_fail(istate);
    147152}
    … …  
    171176        index.value = cp0_index_read();
    172177
     178        page_table_lock(AS, true);     
     179       
    173180        /*
    174181         * Fail if the entry is not in TLB.
    … …  
    190197                         * or copy_to_uspace().
    191198                         */
     199                        page_table_unlock(AS, true);                     
    192200                        return;
    193201                default:
    … …  
    219227        tlbwi();
    220228
     229        page_table_unlock(AS, true);
    221230        return;
    222231       
    223232fail:
     233        page_table_unlock(AS, true);
    224234        tlb_invalid_fail(istate);
    225235}
    … …  
    249259        index.value = cp0_index_read();
    250260
     261        page_table_lock(AS, true);     
     262       
    251263        /*
    252264         * Fail if the entry is not in TLB.
    … …  
    268280                         * or copy_to_uspace().
    269281                         */
     282                        page_table_unlock(AS, true);                     
    270283                        return;
    271284                default:
    … …  
    298311        tlbwi();
    299312
     313        page_table_unlock(AS, true);
    300314        return;
    301315       
    302316fail:
     317        page_table_unlock(AS, true);
    303318        tlb_modified_fail(istate);
    304319}
    … …  
    349364        pte_t *pte;
    350365
     366        ASSERT(mutex_locked(&AS->lock));
     367
    351368        hi.value = cp0_entry_hi_read();
    352369
    … …  
    362379         * Check if the mapping exists in page tables.
    363380         */     
    364         pte = page_mapping_find(AS, badvaddr, true);
     381        pte = page_mapping_find(AS, badvaddr);
    365382        if (pte && pte->p && (pte->w || access != PF_ACCESS_WRITE)) {
    366383                /*
    … …  
    376393                 * Resort to higher-level page fault handler.
    377394                 */
     395                page_table_unlock(AS, true);
    378396                switch (rc = as_page_fault(badvaddr, access, istate)) {
    379397                case AS_PF_OK:
    … …  
    382400                         * The mapping ought to be in place.
    383401                         */
    384                         pte = page_mapping_find(AS, badvaddr, true);
     402                        page_table_lock(AS, true);
     403                        pte = page_mapping_find(AS, badvaddr);
    385404                        ASSERT(pte && pte->p);
    386405                        ASSERT(pte->w || access != PF_ACCESS_WRITE);
    … …  
    388407                        break;
    389408                case AS_PF_DEFER:
     409                        page_table_lock(AS, true);
    390410                        *pfrc = AS_PF_DEFER;
    391411                        return NULL;
    392412                        break;
    393413                case AS_PF_FAULT:
     414                        page_table_lock(AS, true);
    394415                        *pfrc = AS_PF_FAULT;
    395416                        return NULL;

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

    reaeb056 r9ea8fdb4  
    4949 *
    5050 * @param as       Address space.
     51 * @param lock     Lock/unlock the address space.
    5152 * @param badvaddr Faulting virtual address.
    5253 * @param access   Access mode that caused the fault.
    … …  
    6162    istate_t *istate, int *pfrc)
    6263{
     64        ASSERT(mutex_locked(&as->lock));
     65
    6366        /*
    6467         * Check if the mapping exists in page tables.
    6568         */
    66         pte_t *pte = page_mapping_find(as, badvaddr, true);
     69        pte_t *pte = page_mapping_find(as, badvaddr);
    6770        if ((pte) && (pte->present)) {
    6871                /*
    … …  
    7679                 * Resort to higher-level page fault handler.
    7780                 */
     81                page_table_unlock(as, true);
     82               
    7883                int rc = as_page_fault(badvaddr, access, istate);
    7984                switch (rc) {
    … …  
    8388                         * The mapping ought to be in place.
    8489                         */
    85                         pte = page_mapping_find(as, badvaddr, true);
     90                        page_table_lock(as, true);
     91                        pte = page_mapping_find(as, badvaddr);
    8692                        ASSERT((pte) && (pte->present));
    8793                        *pfrc = 0;
    8894                        return pte;
    8995                case AS_PF_DEFER:
     96                        page_table_lock(as, true);
    9097                        *pfrc = rc;
    9198                        return NULL;
    9299                case AS_PF_FAULT:
     100                        page_table_lock(as, true);
    93101                        *pfrc = rc;
    94102                        return NULL;
    … …  
    206214                badvaddr = istate->pc;
    207215       
     216        page_table_lock(as, true);
     217       
    208218        int pfrc;
    209219        pte_t *pte = find_mapping_and_check(as, badvaddr,
    … …  
    213223                switch (pfrc) {
    214224                case AS_PF_FAULT:
     225                        page_table_unlock(as, true);
    215226                        pht_refill_fail(badvaddr, istate);
    216227                        return;
    … …  
    220231                         * or copy_to_uspace().
    221232                         */
     233                        page_table_unlock(as, true);
    222234                        return;
    223235                default:
    … …  
    229241        pte->accessed = 1;
    230242        pht_insert(badvaddr, pte);
     243       
     244        page_table_unlock(as, true);
    231245}
    232246

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

    reaeb056 r9ea8fdb4  
    207207
    208208        page_table_lock(AS, true);
    209         t = page_mapping_find(AS, page_16k, true);
     209        t = page_mapping_find(AS, page_16k);
    210210        if (t && PTE_EXECUTABLE(t)) {
    211211                /*
    … …  
    275275
    276276        page_table_lock(AS, true);
    277         t = page_mapping_find(AS, page_16k, true);
     277        t = page_mapping_find(AS, page_16k);
    278278        if (t) {
    279279                /*
    … …  
    319319
    320320        page_table_lock(AS, true);
    321         t = page_mapping_find(AS, page_16k, true);
     321        t = page_mapping_find(AS, page_16k);
    322322        if (t && PTE_WRITABLE(t)) {
    323323                /*

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

    reaeb056 r9ea8fdb4  
    219219
    220220        page_table_lock(AS, true);
    221         t = page_mapping_find(AS, va, true);
     221        t = page_mapping_find(AS, va);
    222222
    223223        if (t && PTE_EXECUTABLE(t)) {
    … …  
    275275
    276276        page_table_lock(AS, true);
    277         t = page_mapping_find(AS, va, true);
     277        t = page_mapping_find(AS, va);
    278278        if (t) {
    279279                /*
    … …  
    317317
    318318        page_table_lock(AS, true);
    319         t = page_mapping_find(AS, va, true);
     319        t = page_mapping_find(AS, va);
    320320        if (t && PTE_WRITABLE(t)) {
    321321                /*

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

    reaeb056 r9ea8fdb4  
    129129
    130130extern void page_mapping_insert_pt(as_t *, uintptr_t, uintptr_t, unsigned int);
    131 extern pte_t *page_mapping_find_pt(as_t *, uintptr_t, bool);
     131extern pte_t *page_mapping_find_pt(as_t *, uintptr_t);
    132132
    133133#endif

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

    reaeb056 r9ea8fdb4  
    5858static void ht_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    5959static void ht_mapping_remove(as_t *, uintptr_t);
    60 static pte_t *ht_mapping_find(as_t *, uintptr_t, bool);
     60static pte_t *ht_mapping_find(as_t *, uintptr_t);
    6161
    6262/**
    … …  
    214214 * this call visible.
    215215 *
    216  * @param as   Address space to which page belongs.
     216 * @param as   Address space to wich page belongs.
    217217 * @param page Virtual address of the page to be demapped.
    218218 *
    … …  
    237237/** Find mapping for virtual page in page hash table.
    238238 *
    239  * @param as     Address space to which page belongs.
    240  * @param page   Virtual page.
    241  * @param nolock True if the page tables need not be locked.
     239 * Find mapping for virtual page.
     240 *
     241 * @param as   Address space to wich page belongs.
     242 * @param page Virtual page.
    242243 *
    243244 * @return NULL if there is no such mapping; requested mapping otherwise.
    244245 *
    245246 */
    246 pte_t *ht_mapping_find(as_t *as, uintptr_t page, bool nolock)
     247pte_t *ht_mapping_find(as_t *as, uintptr_t page)
    247248{
    248249        sysarg_t key[2] = {
    … …  
    251252        };
    252253
    253         ASSERT(nolock || page_table_locked(as));
     254        ASSERT(page_table_locked(as));
    254255       
    255256        link_t *cur = hash_table_find(&page_ht, key);

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

    reaeb056 r9ea8fdb4  
    4848static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    4949static void pt_mapping_remove(as_t *, uintptr_t);
    50 static pte_t *pt_mapping_find(as_t *, uintptr_t, bool);
     50static pte_t *pt_mapping_find(as_t *, uintptr_t);
    5151
    5252page_mapping_operations_t pt_mapping_operations = {
    … …  
    238238/** Find mapping for virtual page in hierarchical page tables.
    239239 *
    240  * @param as     Address space to which page belongs.
    241  * @param page   Virtual page.
    242  * @param nolock True if the page tables need not be locked.
     240 * Find mapping for virtual page.
     241 *
     242 * @param as   Address space to which page belongs.
     243 * @param page Virtual page.
    243244 *
    244245 * @return NULL if there is no such mapping; entry from PTL3 describing
    … …  
    246247 *
    247248 */
    248 pte_t *pt_mapping_find(as_t *as, uintptr_t page, bool nolock)
     249pte_t *pt_mapping_find(as_t *as, uintptr_t page)
    249250{
    250         ASSERT(nolock || page_table_locked(as));
     251        ASSERT(page_table_locked(as));
    251252
    252253        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);

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

    reaeb056 r9ea8fdb4  
    4747        void (* mapping_insert)(as_t *, uintptr_t, uintptr_t, unsigned int);
    4848        void (* mapping_remove)(as_t *, uintptr_t);
    49         pte_t *(* mapping_find)(as_t *, uintptr_t, bool);
     49        pte_t *(* mapping_find)(as_t *, uintptr_t);
    5050} page_mapping_operations_t;
    5151
    … …  
    5858extern void page_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    5959extern void page_mapping_remove(as_t *, uintptr_t);
    60 extern pte_t *page_mapping_find(as_t *, uintptr_t, bool);
     60extern pte_t *page_mapping_find(as_t *, uintptr_t);
    6161extern pte_t *page_table_create(unsigned int);
    6262extern void page_table_destroy(pte_t *);

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

    reaeb056 r9ea8fdb4  
    649649                                for (; i < size; i++) {
    650650                                        pte_t *pte = page_mapping_find(as,
    651                                             ptr + P2SZ(i), false);
     651                                            ptr + P2SZ(i));
    652652                                       
    653653                                        ASSERT(pte);
    … …  
    798798                        for (size = 0; size < (size_t) node->value[i]; size++) {
    799799                                pte_t *pte = page_mapping_find(as,
    800                                      ptr + P2SZ(size), false);
     800                                     ptr + P2SZ(size));
    801801                               
    802802                                ASSERT(pte);
    … …  
    11051105                        for (size = 0; size < (size_t) node->value[i]; size++) {
    11061106                                pte_t *pte = page_mapping_find(as,
    1107                                     ptr + P2SZ(size), false);
     1107                                    ptr + P2SZ(size));
    11081108                               
    11091109                                ASSERT(pte);
    … …  
    12411241         */
    12421242        pte_t *pte;
    1243         if ((pte = page_mapping_find(AS, page, false))) {
     1243        if ((pte = page_mapping_find(AS, page))) {
    12441244                if (PTE_PRESENT(pte)) {
    12451245                        if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||

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

    reaeb056 r9ea8fdb4  
    122122                                page_table_lock(area->as, false);
    123123                                pte = page_mapping_find(area->as,
    124                                     base + P2SZ(j), false);
     124                                    base + j * PAGE_SIZE);
    125125                                ASSERT(pte && PTE_VALID(pte) &&
    126126                                    PTE_PRESENT(pte));
    127127                                btree_insert(&area->sh_info->pagemap,
    128                                     (base + P2SZ(j)) - area->base,
     128                                    (base + j * PAGE_SIZE) - area->base,
    129129                                    (void *) PTE_GET_FRAME(pte), NULL);
    130130                                page_table_unlock(area->as, false);

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

    reaeb056 r9ea8fdb4  
    170170                        if (!(area->flags & AS_AREA_WRITE))
    171171                                if (base >= entry->p_vaddr &&
    172                                     base + P2SZ(count) <= start_anon)
     172                                    base + count * PAGE_SIZE <= start_anon)
    173173                                        continue;
    174174                       
    … …  
    182182                                if (!(area->flags & AS_AREA_WRITE))
    183183                                        if (base >= entry->p_vaddr &&
    184                                             base + P2SZ(j + 1) <= start_anon)
     184                                            base + (j + 1) * PAGE_SIZE <=
     185                                            start_anon)
    185186                                                continue;
    186187                               
    187188                                page_table_lock(area->as, false);
    188189                                pte = page_mapping_find(area->as,
    189                                     base + P2SZ(j), false);
     190                                    base + j * PAGE_SIZE);
    190191                                ASSERT(pte && PTE_VALID(pte) &&
    191192                                    PTE_PRESENT(pte));
    192193                                btree_insert(&area->sh_info->pagemap,
    193                                     (base + P2SZ(j)) - area->base,
     194                                    (base + j * PAGE_SIZE) - area->base,
    194195                                    (void *) PTE_GET_FRAME(pte), NULL);
    195196                                page_table_unlock(area->as, false);

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

    reaeb056 r9ea8fdb4  
    108108 * using flags. Allocate and setup any missing page tables.
    109109 *
    110  * @param as    Address space to which page belongs.
     110 * @param as    Address space to wich page belongs.
    111111 * @param page  Virtual address of the page to be mapped.
    112112 * @param frame Physical address of memory frame to which the mapping is
    … …  
    135135 * this call visible.
    136136 *
    137  * @param as   Address space to which page belongs.
     137 * @param as   Address space to wich page belongs.
    138138 * @param page Virtual address of the page to be demapped.
    139139 *
    … …  
    152152}
    153153
    154 /** Find mapping for virtual page.
     154/** Find mapping for virtual page
    155155 *
    156  * @param as     Address space to which page belongs.
    157  * @param page   Virtual page.
    158  * @param nolock True if the page tables need not be locked.
     156 * Find mapping for virtual page.
     157 *
     158 * @param as   Address space to wich page belongs.
     159 * @param page Virtual page.
    159160 *
    160161 * @return NULL if there is no such mapping; requested mapping
    … …  
    162163 *
    163164 */
    164 NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
     165NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page)
    165166{
    166         ASSERT(nolock || page_table_locked(as));
     167        ASSERT(page_table_locked(as));
    167168       
    168169        ASSERT(page_mapping_operations);
    169170        ASSERT(page_mapping_operations->mapping_find);
    170171       
    171         return page_mapping_operations->mapping_find(as, page, nolock);
     172        return page_mapping_operations->mapping_find(as, page);
    172173}
    173174

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

    reaeb056 r9ea8fdb4  
    119119         */
    120120        page_table_lock(AS, true);
    121         t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
     121        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
    122122        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    123123                page_table_unlock(AS, true);
    … …  
    155155         */
    156156        page_table_lock(AS, true);
    157         t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
     157        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
    158158        if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
    159159                page_table_unlock(AS, true);
Note: See TracChangeset for help on using the changeset viewer.