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

Changeset 0ff03f3 in mainline


Ignore:
Timestamp:
2011-05-21T16:23:43Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
235e6c7
Parents:
9d47440
Message:

Allow calling page_mapping_find() with unlocked page tables.

Location:
kernel
Files:
11 edited

Legend:

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

    r9d47440 r0ff03f3  
    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

    r9d47440 r0ff03f3  
    379379         * Check if the mapping exists in page tables.
    380380         */     
    381         pte = page_mapping_find(AS, badvaddr);
     381        pte = page_mapping_find(AS, badvaddr, true);
    382382        if (pte && pte->p && (pte->w || access != PF_ACCESS_WRITE)) {
    383383                /*
     
    401401                         */
    402402                        page_table_lock(AS, true);
    403                         pte = page_mapping_find(AS, badvaddr);
     403                        pte = page_mapping_find(AS, badvaddr, true);
    404404                        ASSERT(pte && pte->p);
    405405                        ASSERT(pte->w || access != PF_ACCESS_WRITE);
  • kernel/arch/ppc32/src/mm/tlb.c

    r9d47440 r0ff03f3  
    6767         * Check if the mapping exists in page tables.
    6868         */
    69         pte_t *pte = page_mapping_find(as, badvaddr);
     69        pte_t *pte = page_mapping_find(as, badvaddr, true);
    7070        if ((pte) && (pte->present)) {
    7171                /*
     
    8989                         */
    9090                        page_table_lock(as, true);
    91                         pte = page_mapping_find(as, badvaddr);
     91                        pte = page_mapping_find(as, badvaddr, true);
    9292                        ASSERT((pte) && (pte->present));
    9393                        *pfrc = 0;
  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r9d47440 r0ff03f3  
    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

    r9d47440 r0ff03f3  
    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/generic/include/mm/page.h

    r9d47440 r0ff03f3  
    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

    r9d47440 r0ff03f3  
    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

    r9d47440 r0ff03f3  
    122122                                page_table_lock(area->as, false);
    123123                                pte = page_mapping_find(area->as,
    124                                     base + j * PAGE_SIZE);
     124                                    base + j * PAGE_SIZE, false);
    125125                                ASSERT(pte && PTE_VALID(pte) &&
    126126                                    PTE_PRESENT(pte));
  • kernel/generic/src/mm/backend_elf.c

    r9d47440 r0ff03f3  
    188188                                page_table_lock(area->as, false);
    189189                                pte = page_mapping_find(area->as,
    190                                     base + j * PAGE_SIZE);
     190                                    base + j * PAGE_SIZE, false);
    191191                                ASSERT(pte && PTE_VALID(pte) &&
    192192                                    PTE_PRESENT(pte));
  • kernel/generic/src/mm/page.c

    r9d47440 r0ff03f3  
    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);
  • kernel/generic/src/synch/futex.c

    r9d47440 r0ff03f3  
    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.