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

Changeset eaeb056 in mainline


Ignore:
Timestamp:
2011-05-22T20:05:26Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
34efa8a
Parents:
9ea8fdb4 (diff), 2bdf8313 (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/mm.

Location:
kernel
Files:
14 edited

Legend:

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

    r9ea8fdb4 reaeb056  
    481481       
    482482        page_table_lock(AS, true);
    483         t = page_mapping_find(AS, va);
     483        t = page_mapping_find(AS, va, true);
    484484        if (t) {
    485485                /*
     
    599599       
    600600        page_table_lock(AS, true);
    601         pte_t *entry = page_mapping_find(AS, va);
     601        pte_t *entry = page_mapping_find(AS, va, true);
    602602        if (entry) {
    603603                /*
     
    651651       
    652652        page_table_lock(AS, true);
    653         t = page_mapping_find(AS, va);
     653        t = page_mapping_find(AS, va, true);
    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);
     686        t = page_mapping_find(AS, va, true);
    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);
     719        t = page_mapping_find(AS, va, true);
    720720        ASSERT((t) && (t->p));
    721721        if ((t) && (t->p)) {
     
    753753         */
    754754        page_table_lock(AS, true);
    755         t = page_mapping_find(AS, va);
     755        t = page_mapping_find(AS, va, true);
    756756        ASSERT((t) && (t->p));
    757757        ASSERT(!t->w);
     
    778778       
    779779        page_table_lock(AS, true);
    780         t = page_mapping_find(AS, va);
     780        t = page_mapping_find(AS, va, true);
    781781        ASSERT(t);
    782782       
  • kernel/arch/mips32/src/mm/tlb.c

    r9ea8fdb4 reaeb056  
    100100        mutex_unlock(&AS->lock);
    101101       
    102         page_table_lock(AS, true);
    103        
    104102        pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
    105103        if (!pte) {
     
    113111                         * or copy_to_uspace().
    114112                         */
    115                         page_table_unlock(AS, true);
    116113                        return;
    117114                default:
     
    144141        tlbwr();
    145142
    146         page_table_unlock(AS, true);
    147143        return;
    148144       
    149145fail:
    150         page_table_unlock(AS, true);
    151146        tlb_refill_fail(istate);
    152147}
     
    176171        index.value = cp0_index_read();
    177172
    178         page_table_lock(AS, true);     
    179        
    180173        /*
    181174         * Fail if the entry is not in TLB.
     
    197190                         * or copy_to_uspace().
    198191                         */
    199                         page_table_unlock(AS, true);                     
    200192                        return;
    201193                default:
     
    227219        tlbwi();
    228220
    229         page_table_unlock(AS, true);
    230221        return;
    231222       
    232223fail:
    233         page_table_unlock(AS, true);
    234224        tlb_invalid_fail(istate);
    235225}
     
    259249        index.value = cp0_index_read();
    260250
    261         page_table_lock(AS, true);     
    262        
    263251        /*
    264252         * Fail if the entry is not in TLB.
     
    280268                         * or copy_to_uspace().
    281269                         */
    282                         page_table_unlock(AS, true);                     
    283270                        return;
    284271                default:
     
    311298        tlbwi();
    312299
    313         page_table_unlock(AS, true);
    314300        return;
    315301       
    316302fail:
    317         page_table_unlock(AS, true);
    318303        tlb_modified_fail(istate);
    319304}
     
    364349        pte_t *pte;
    365350
    366         ASSERT(mutex_locked(&AS->lock));
    367 
    368351        hi.value = cp0_entry_hi_read();
    369352
     
    379362         * Check if the mapping exists in page tables.
    380363         */     
    381         pte = page_mapping_find(AS, badvaddr);
     364        pte = page_mapping_find(AS, badvaddr, true);
    382365        if (pte && pte->p && (pte->w || access != PF_ACCESS_WRITE)) {
    383366                /*
     
    393376                 * Resort to higher-level page fault handler.
    394377                 */
    395                 page_table_unlock(AS, true);
    396378                switch (rc = as_page_fault(badvaddr, access, istate)) {
    397379                case AS_PF_OK:
     
    400382                         * The mapping ought to be in place.
    401383                         */
    402                         page_table_lock(AS, true);
    403                         pte = page_mapping_find(AS, badvaddr);
     384                        pte = page_mapping_find(AS, badvaddr, true);
    404385                        ASSERT(pte && pte->p);
    405386                        ASSERT(pte->w || access != PF_ACCESS_WRITE);
     
    407388                        break;
    408389                case AS_PF_DEFER:
    409                         page_table_lock(AS, true);
    410390                        *pfrc = AS_PF_DEFER;
    411391                        return NULL;
    412392                        break;
    413393                case AS_PF_FAULT:
    414                         page_table_lock(AS, true);
    415394                        *pfrc = AS_PF_FAULT;
    416395                        return NULL;
  • kernel/arch/ppc32/src/mm/tlb.c

    r9ea8fdb4 reaeb056  
    4949 *
    5050 * @param as       Address space.
    51  * @param lock     Lock/unlock the address space.
    5251 * @param badvaddr Faulting virtual address.
    5352 * @param access   Access mode that caused the fault.
     
    6261    istate_t *istate, int *pfrc)
    6362{
    64         ASSERT(mutex_locked(&as->lock));
    65 
    6663        /*
    6764         * Check if the mapping exists in page tables.
    6865         */
    69         pte_t *pte = page_mapping_find(as, badvaddr);
     66        pte_t *pte = page_mapping_find(as, badvaddr, true);
    7067        if ((pte) && (pte->present)) {
    7168                /*
     
    7976                 * Resort to higher-level page fault handler.
    8077                 */
    81                 page_table_unlock(as, true);
    82                
    8378                int rc = as_page_fault(badvaddr, access, istate);
    8479                switch (rc) {
     
    8883                         * The mapping ought to be in place.
    8984                         */
    90                         page_table_lock(as, true);
    91                         pte = page_mapping_find(as, badvaddr);
     85                        pte = page_mapping_find(as, badvaddr, true);
    9286                        ASSERT((pte) && (pte->present));
    9387                        *pfrc = 0;
    9488                        return pte;
    9589                case AS_PF_DEFER:
    96                         page_table_lock(as, true);
    9790                        *pfrc = rc;
    9891                        return NULL;
    9992                case AS_PF_FAULT:
    100                         page_table_lock(as, true);
    10193                        *pfrc = rc;
    10294                        return NULL;
     
    214206                badvaddr = istate->pc;
    215207       
    216         page_table_lock(as, true);
    217        
    218208        int pfrc;
    219209        pte_t *pte = find_mapping_and_check(as, badvaddr,
     
    223213                switch (pfrc) {
    224214                case AS_PF_FAULT:
    225                         page_table_unlock(as, true);
    226215                        pht_refill_fail(badvaddr, istate);
    227216                        return;
     
    231220                         * or copy_to_uspace().
    232221                         */
    233                         page_table_unlock(as, true);
    234222                        return;
    235223                default:
     
    241229        pte->accessed = 1;
    242230        pht_insert(badvaddr, pte);
    243        
    244         page_table_unlock(as, true);
    245231}
    246232
  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r9ea8fdb4 reaeb056  
    207207
    208208        page_table_lock(AS, true);
    209         t = page_mapping_find(AS, page_16k);
     209        t = page_mapping_find(AS, page_16k, true);
    210210        if (t && PTE_EXECUTABLE(t)) {
    211211                /*
     
    275275
    276276        page_table_lock(AS, true);
    277         t = page_mapping_find(AS, page_16k);
     277        t = page_mapping_find(AS, page_16k, true);
    278278        if (t) {
    279279                /*
     
    319319
    320320        page_table_lock(AS, true);
    321         t = page_mapping_find(AS, page_16k);
     321        t = page_mapping_find(AS, page_16k, true);
    322322        if (t && PTE_WRITABLE(t)) {
    323323                /*
  • kernel/arch/sparc64/src/mm/sun4v/tlb.c

    r9ea8fdb4 reaeb056  
    219219
    220220        page_table_lock(AS, true);
    221         t = page_mapping_find(AS, va);
     221        t = page_mapping_find(AS, va, true);
    222222
    223223        if (t && PTE_EXECUTABLE(t)) {
     
    275275
    276276        page_table_lock(AS, true);
    277         t = page_mapping_find(AS, va);
     277        t = page_mapping_find(AS, va, true);
    278278        if (t) {
    279279                /*
     
    317317
    318318        page_table_lock(AS, true);
    319         t = page_mapping_find(AS, va);
     319        t = page_mapping_find(AS, va, true);
    320320        if (t && PTE_WRITABLE(t)) {
    321321                /*
  • kernel/genarch/include/mm/page_pt.h

    r9ea8fdb4 reaeb056  
    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);
     131extern pte_t *page_mapping_find_pt(as_t *, uintptr_t, bool);
    132132
    133133#endif
  • kernel/genarch/src/mm/page_ht.c

    r9ea8fdb4 reaeb056  
    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);
     60static pte_t *ht_mapping_find(as_t *, uintptr_t, bool);
    6161
    6262/**
     
    214214 * this call visible.
    215215 *
    216  * @param as   Address space to wich page belongs.
     216 * @param as   Address space to which 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  * Find mapping for virtual page.
    240  *
    241  * @param as   Address space to wich page belongs.
    242  * @param page Virtual page.
     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.
    243242 *
    244243 * @return NULL if there is no such mapping; requested mapping otherwise.
    245244 *
    246245 */
    247 pte_t *ht_mapping_find(as_t *as, uintptr_t page)
     246pte_t *ht_mapping_find(as_t *as, uintptr_t page, bool nolock)
    248247{
    249248        sysarg_t key[2] = {
     
    252251        };
    253252
    254         ASSERT(page_table_locked(as));
     253        ASSERT(nolock || page_table_locked(as));
    255254       
    256255        link_t *cur = hash_table_find(&page_ht, key);
  • kernel/genarch/src/mm/page_pt.c

    r9ea8fdb4 reaeb056  
    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);
     50static pte_t *pt_mapping_find(as_t *, uintptr_t, bool);
    5151
    5252page_mapping_operations_t pt_mapping_operations = {
     
    238238/** Find mapping for virtual page in hierarchical page tables.
    239239 *
    240  * Find mapping for virtual page.
    241  *
    242  * @param as   Address space to which page belongs.
    243  * @param page Virtual page.
     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.
    244243 *
    245244 * @return NULL if there is no such mapping; entry from PTL3 describing
     
    247246 *
    248247 */
    249 pte_t *pt_mapping_find(as_t *as, uintptr_t page)
     248pte_t *pt_mapping_find(as_t *as, uintptr_t page, bool nolock)
    250249{
    251         ASSERT(page_table_locked(as));
     250        ASSERT(nolock || page_table_locked(as));
    252251
    253252        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
  • kernel/generic/include/mm/page.h

    r9ea8fdb4 reaeb056  
    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);
     49        pte_t *(* mapping_find)(as_t *, uintptr_t, bool);
    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);
     60extern pte_t *page_mapping_find(as_t *, uintptr_t, bool);
    6161extern pte_t *page_table_create(unsigned int);
    6262extern void page_table_destroy(pte_t *);
  • kernel/generic/src/mm/as.c

    r9ea8fdb4 reaeb056  
    649649                                for (; i < size; i++) {
    650650                                        pte_t *pte = page_mapping_find(as,
    651                                             ptr + P2SZ(i));
     651                                            ptr + P2SZ(i), false);
    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));
     800                                     ptr + P2SZ(size), false);
    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));
     1107                                    ptr + P2SZ(size), false);
    11081108                               
    11091109                                ASSERT(pte);
     
    12411241         */
    12421242        pte_t *pte;
    1243         if ((pte = page_mapping_find(AS, page))) {
     1243        if ((pte = page_mapping_find(AS, page, false))) {
    12441244                if (PTE_PRESENT(pte)) {
    12451245                        if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
  • kernel/generic/src/mm/backend_anon.c

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

    r9ea8fdb4 reaeb056  
    170170                        if (!(area->flags & AS_AREA_WRITE))
    171171                                if (base >= entry->p_vaddr &&
    172                                     base + count * PAGE_SIZE <= start_anon)
     172                                    base + P2SZ(count) <= start_anon)
    173173                                        continue;
    174174                       
     
    182182                                if (!(area->flags & AS_AREA_WRITE))
    183183                                        if (base >= entry->p_vaddr &&
    184                                             base + (j + 1) * PAGE_SIZE <=
    185                                             start_anon)
     184                                            base + P2SZ(j + 1) <= start_anon)
    186185                                                continue;
    187186                               
    188187                                page_table_lock(area->as, false);
    189188                                pte = page_mapping_find(area->as,
    190                                     base + j * PAGE_SIZE);
     189                                    base + P2SZ(j), false);
    191190                                ASSERT(pte && PTE_VALID(pte) &&
    192191                                    PTE_PRESENT(pte));
    193192                                btree_insert(&area->sh_info->pagemap,
    194                                     (base + j * PAGE_SIZE) - area->base,
     193                                    (base + P2SZ(j)) - area->base,
    195194                                    (void *) PTE_GET_FRAME(pte), NULL);
    196195                                page_table_unlock(area->as, false);
  • kernel/generic/src/mm/page.c

    r9ea8fdb4 reaeb056  
    108108 * using flags. Allocate and setup any missing page tables.
    109109 *
    110  * @param as    Address space to wich page belongs.
     110 * @param as    Address space to which 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 wich page belongs.
     137 * @param as   Address space to which 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  * Find mapping for virtual page.
    157  *
    158  * @param as   Address space to wich page belongs.
    159  * @param page Virtual page.
     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.
    160159 *
    161160 * @return NULL if there is no such mapping; requested mapping
     
    163162 *
    164163 */
    165 NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page)
     164NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
    166165{
    167         ASSERT(page_table_locked(as));
     166        ASSERT(nolock || page_table_locked(as));
    168167       
    169168        ASSERT(page_mapping_operations);
    170169        ASSERT(page_mapping_operations->mapping_find);
    171170       
    172         return page_mapping_operations->mapping_find(as, page);
     171        return page_mapping_operations->mapping_find(as, page, nolock);
    173172}
    174173
  • kernel/generic/src/synch/futex.c

    r9ea8fdb4 reaeb056  
    119119         */
    120120        page_table_lock(AS, true);
    121         t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE));
     121        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
    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));
     157        t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), false);
    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.