Changeset 38dc82d in mainline for kernel/generic/src/mm


Ignore:
Timestamp:
2016-08-31T14:16:45Z (9 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
346b12a2
Parents:
dc05a9a
Message:

Make page_mapping_find() return a copy rather than the actual PTE

This makes page_mapping_find() more suitable for use with lock-free data
structures such as CHT that guarantee existence of the data only for
some limited time while a condition holds (e.g. inside of a RCU-protected
critical section that must be around all CHT lookups).

Location:
kernel/generic/src/mm
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    rdc05a9a r38dc82d  
    888888               
    889889                                for (; i < node_size; i++) {
    890                                         pte_t *pte = page_mapping_find(as,
    891                                             ptr + P2SZ(i), false);
     890                                        pte_t pte;
     891                                        bool found = page_mapping_find(as,
     892                                            ptr + P2SZ(i), false, &pte);
    892893                                       
    893                                         ASSERT(pte);
    894                                         ASSERT(PTE_VALID(pte));
    895                                         ASSERT(PTE_PRESENT(pte));
     894                                        ASSERT(found);
     895                                        ASSERT(PTE_VALID(&pte));
     896                                        ASSERT(PTE_PRESENT(&pte));
    896897                                       
    897898                                        if ((area->backend) &&
    … …  
    899900                                                area->backend->frame_free(area,
    900901                                                    ptr + P2SZ(i),
    901                                                     PTE_GET_FRAME(pte));
     902                                                    PTE_GET_FRAME(&pte));
    902903                                        }
    903904                                       
    … …  
    10021003                       
    10031004                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1004                                 pte_t *pte = page_mapping_find(as,
    1005                                      ptr + P2SZ(size), false);
     1005                                pte_t pte;
     1006                                bool found = page_mapping_find(as,
     1007                                     ptr + P2SZ(size), false, &pte);
    10061008                               
    1007                                 ASSERT(pte);
    1008                                 ASSERT(PTE_VALID(pte));
    1009                                 ASSERT(PTE_PRESENT(pte));
     1009                                ASSERT(found);
     1010                                ASSERT(PTE_VALID(&pte));
     1011                                ASSERT(PTE_PRESENT(&pte));
    10101012                               
    10111013                                if ((area->backend) &&
    … …  
    10131015                                        area->backend->frame_free(area,
    10141016                                            ptr + P2SZ(size),
    1015                                             PTE_GET_FRAME(pte));
     1017                                            PTE_GET_FRAME(&pte));
    10161018                                }
    10171019                               
    … …  
    13141316                       
    13151317                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1316                                 pte_t *pte = page_mapping_find(as,
    1317                                     ptr + P2SZ(size), false);
     1318                                pte_t pte;
     1319                                bool found = page_mapping_find(as,
     1320                                    ptr + P2SZ(size), false, &pte);
    13181321                               
    1319                                 ASSERT(pte);
    1320                                 ASSERT(PTE_VALID(pte));
    1321                                 ASSERT(PTE_PRESENT(pte));
     1322                                ASSERT(found);
     1323                                ASSERT(PTE_VALID(&pte));
     1324                                ASSERT(PTE_PRESENT(&pte));
    13221325                               
    1323                                 old_frame[frame_idx++] = PTE_GET_FRAME(pte);
     1326                                old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
    13241327                               
    13251328                                /* Remove old mapping */
    … …  
    14511454         * we need to make sure the mapping has not been already inserted.
    14521455         */
    1453         pte_t *pte;
    1454         if ((pte = page_mapping_find(AS, page, false))) {
    1455                 if (PTE_PRESENT(pte)) {
    1456                         if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
    1457                             (access == PF_ACCESS_WRITE && PTE_WRITABLE(pte)) ||
    1458                             (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(pte))) {
     1456        pte_t pte;
     1457        bool found = page_mapping_find(AS, page, false, &pte);
     1458        if (found) {
     1459                if (PTE_PRESENT(&pte)) {
     1460                        if (((access == PF_ACCESS_READ) && PTE_READABLE(&pte)) ||
     1461                            (access == PF_ACCESS_WRITE && PTE_WRITABLE(&pte)) ||
     1462                            (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(&pte))) {
    14591463                                page_table_unlock(AS, false);
    14601464                                mutex_unlock(&area->lock);

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

    rdc05a9a r38dc82d  
    131131                       
    132132                        for (j = 0; j < count; j++) {
    133                                 pte_t *pte;
     133                                pte_t pte;
     134                                bool found;
    134135                       
    135136                                page_table_lock(area->as, false);
    136                                 pte = page_mapping_find(area->as,
    137                                     base + P2SZ(j), false);
    138                                 ASSERT(pte && PTE_VALID(pte) &&
    139                                     PTE_PRESENT(pte));
     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
    140144                                btree_insert(&area->sh_info->pagemap,
    141145                                    (base + P2SZ(j)) - area->base,
    142                                     (void *) PTE_GET_FRAME(pte), NULL);
     146                                    (void *) PTE_GET_FRAME(&pte), NULL);
    143147                                page_table_unlock(area->as, false);
    144148
    145                                 pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
     149                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(&pte));
    146150                                frame_reference_add(pfn);
    147151                        }

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

    rdc05a9a r38dc82d  
    184184                       
    185185                        for (j = 0; j < count; j++) {
    186                                 pte_t *pte;
     186                                pte_t pte;
     187                                bool found;
    187188                       
    188189                                /*
    … …  
    196197                               
    197198                                page_table_lock(area->as, false);
    198                                 pte = page_mapping_find(area->as,
    199                                     base + P2SZ(j), false);
    200                                 ASSERT(pte && PTE_VALID(pte) &&
    201                                     PTE_PRESENT(pte));
     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
    202206                                btree_insert(&area->sh_info->pagemap,
    203207                                    (base + P2SZ(j)) - area->base,
    204                                     (void *) PTE_GET_FRAME(pte), NULL);
     208                                    (void *) PTE_GET_FRAME(&pte), NULL);
    205209                                page_table_unlock(area->as, false);
    206210
    207                                 pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(pte));
     211                                pfn_t pfn = ADDR2PFN(PTE_GET_FRAME(&pte));
    208212                                frame_reference_add(pfn);
    209213                        }
    … …  
    335339                        dirty = true;
    336340                } else {
    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);
     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);
    344351                }       
    345352        } else if (upage >= start_anon) {

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

    rdc05a9a r38dc82d  
    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  *
    143  * @return NULL if there is no such mapping; requested mapping
    144  *         otherwise.
    145  *
    146  */
    147 NO_TRACE pte_t *page_mapping_find(as_t *as, uintptr_t page, bool nolock)
     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 */
     146NO_TRACE bool page_mapping_find(as_t *as, uintptr_t page, bool nolock,
     147    pte_t *pte)
    148148{
    149149        ASSERT(nolock || page_table_locked(as));
    … …  
    153153       
    154154        return page_mapping_operations->mapping_find(as,
    155             ALIGN_DOWN(page, PAGE_SIZE), nolock);
     155            ALIGN_DOWN(page, PAGE_SIZE), nolock, pte);
    156156}
    157157
    … …  
    173173        page_table_lock(AS, true);
    174174       
    175         pte_t *pte = page_mapping_find(AS, virt, false);
    176         if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
     175        pte_t pte;
     176        bool found = page_mapping_find(AS, virt, false, &pte);
     177        if (!found || !PTE_VALID(&pte) || !PTE_PRESENT(&pte)) {
    177178                page_table_unlock(AS, true);
    178179                return ENOENT;
    179180        }
    180181       
    181         *phys = PTE_GET_FRAME(pte) +
     182        *phys = PTE_GET_FRAME(&pte) +
    182183            (virt - ALIGN_DOWN(virt, PAGE_SIZE));
    183184       
Note: See TracChangeset for help on using the changeset viewer.