Changeset 2c2d54a in mainline for kernel/generic/src/mm


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/generic/src/mm
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

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

    r4bf0926e r2c2d54a  
    574574 * @param backend_data NULL or a pointer to custom backend data.
    575575 * @param base         Starting virtual address of the area.
    576  *                     If set to -1, a suitable mappable area is found.
    577  * @param bound        Lowest address bound if base is set to -1.
     576 *                     If set to AS_AREA_ANY, a suitable mappable area is
     577 *                     found.
     578 * @param bound        Lowest address bound if base is set to AS_AREA_ANY.
    578579 *                     Otherwise ignored.
    579580 *
    … …  
    585586    mem_backend_data_t *backend_data, uintptr_t *base, uintptr_t bound)
    586587{
    587         if ((*base != (uintptr_t) -1) && !IS_ALIGNED(*base, PAGE_SIZE))
     588        if ((*base != (uintptr_t) AS_AREA_ANY) && !IS_ALIGNED(*base, PAGE_SIZE))
    588589                return NULL;
    589590       
    … …  
    601602        mutex_lock(&as->lock);
    602603       
    603         if (*base == (uintptr_t) -1) {
     604        if (*base == (uintptr_t) AS_AREA_ANY) {
    604605                *base = as_get_unmapped_area(as, bound, size, guarded);
    605606                if (*base == (uintptr_t) -1) {
    … …  
    888889               
    889890                                for (; i < node_size; i++) {
    890                                         pte_t *pte = page_mapping_find(as,
    891                                             ptr + P2SZ(i), false);
     891                                        pte_t pte;
     892                                        bool found = page_mapping_find(as,
     893                                            ptr + P2SZ(i), false, &pte);
    892894                                       
    893                                         ASSERT(pte);
    894                                         ASSERT(PTE_VALID(pte));
    895                                         ASSERT(PTE_PRESENT(pte));
     895                                        ASSERT(found);
     896                                        ASSERT(PTE_VALID(&pte));
     897                                        ASSERT(PTE_PRESENT(&pte));
    896898                                       
    897899                                        if ((area->backend) &&
    … …  
    899901                                                area->backend->frame_free(area,
    900902                                                    ptr + P2SZ(i),
    901                                                     PTE_GET_FRAME(pte));
     903                                                    PTE_GET_FRAME(&pte));
    902904                                        }
    903905                                       
    … …  
    10021004                       
    10031005                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1004                                 pte_t *pte = page_mapping_find(as,
    1005                                      ptr + P2SZ(size), false);
     1006                                pte_t pte;
     1007                                bool found = page_mapping_find(as,
     1008                                     ptr + P2SZ(size), false, &pte);
    10061009                               
    1007                                 ASSERT(pte);
    1008                                 ASSERT(PTE_VALID(pte));
    1009                                 ASSERT(PTE_PRESENT(pte));
     1010                                ASSERT(found);
     1011                                ASSERT(PTE_VALID(&pte));
     1012                                ASSERT(PTE_PRESENT(&pte));
    10101013                               
    10111014                                if ((area->backend) &&
    … …  
    10131016                                        area->backend->frame_free(area,
    10141017                                            ptr + P2SZ(size),
    1015                                             PTE_GET_FRAME(pte));
     1018                                            PTE_GET_FRAME(&pte));
    10161019                                }
    10171020                               
    … …  
    13141317                       
    13151318                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1316                                 pte_t *pte = page_mapping_find(as,
    1317                                     ptr + P2SZ(size), false);
     1319                                pte_t pte;
     1320                                bool found = page_mapping_find(as,
     1321                                    ptr + P2SZ(size), false, &pte);
    13181322                               
    1319                                 ASSERT(pte);
    1320                                 ASSERT(PTE_VALID(pte));
    1321                                 ASSERT(PTE_PRESENT(pte));
     1323                                ASSERT(found);
     1324                                ASSERT(PTE_VALID(&pte));
     1325                                ASSERT(PTE_PRESENT(&pte));
    13221326                               
    1323                                 old_frame[frame_idx++] = PTE_GET_FRAME(pte);
     1327                                old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
    13241328                               
    13251329                                /* Remove old mapping */
    … …  
    14511455         * we need to make sure the mapping has not been already inserted.
    14521456         */
    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))) {
     1457        pte_t pte;
     1458        bool found = page_mapping_find(AS, page, false, &pte);
     1459        if (found) {
     1460                if (PTE_PRESENT(&pte)) {
     1461                        if (((access == PF_ACCESS_READ) && PTE_READABLE(&pte)) ||
     1462                            (access == PF_ACCESS_WRITE && PTE_WRITABLE(&pte)) ||
     1463                            (access == PF_ACCESS_EXEC && PTE_EXECUTABLE(&pte))) {
    14591464                                page_table_unlock(AS, false);
    14601465                                mutex_unlock(&area->lock);
    … …  
    21822187
    21832188sysarg_t sys_as_area_create(uintptr_t base, size_t size, unsigned int flags,
    2184     uintptr_t bound)
     2189    uintptr_t bound, as_area_pager_info_t *pager_info)
    21852190{
    21862191        uintptr_t virt = base;
     2192        mem_backend_t *backend;
     2193        mem_backend_data_t backend_data;
     2194
     2195        if (pager_info == AS_AREA_UNPAGED)
     2196                backend = &anon_backend;
     2197        else {
     2198                backend = &user_backend;
     2199                if (copy_from_uspace(&backend_data.pager_info, pager_info,
     2200                        sizeof(as_area_pager_info_t)) != EOK) {
     2201                        return (sysarg_t) AS_MAP_FAILED;
     2202                }
     2203        }
    21872204        as_area_t *area = as_area_create(AS, flags, size,
    2188             AS_AREA_ATTR_NONE, &anon_backend, NULL, &virt, bound);
     2205            AS_AREA_ATTR_NONE, backend, &backend_data, &virt, bound);
    21892206        if (area == NULL)
    2190                 return (sysarg_t) -1;
     2207                return (sysarg_t) AS_MAP_FAILED;
    21912208       
    21922209        return (sysarg_t) virt;

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

    r4bf0926e r2c2d54a  
    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

    r4bf0926e r2c2d54a  
    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

    r4bf0926e r2c2d54a  
    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);
     156}
     157
     158/** Update mapping for virtual page.
     159 *
     160 * Use only to update accessed and modified/dirty bits.
     161 *
     162 * @param as       Address space to which page belongs.
     163 * @param page     Virtual page.
     164 * @param nolock   True if the page tables need not be locked.
     165 * @param pte      New PTE.
     166 */
     167NO_TRACE void page_mapping_update(as_t *as, uintptr_t page, bool nolock,
     168    pte_t *pte)
     169{
     170        ASSERT(nolock || page_table_locked(as));
     171       
     172        ASSERT(page_mapping_operations);
     173        ASSERT(page_mapping_operations->mapping_find);
     174       
     175        page_mapping_operations->mapping_update(as,
     176            ALIGN_DOWN(page, PAGE_SIZE), nolock, pte);
    156177}
    157178
    … …  
    173194        page_table_lock(AS, true);
    174195       
    175         pte_t *pte = page_mapping_find(AS, virt, false);
    176         if ((!PTE_VALID(pte)) || (!PTE_PRESENT(pte))) {
     196        pte_t pte;
     197        bool found = page_mapping_find(AS, virt, false, &pte);
     198        if (!found || !PTE_VALID(&pte) || !PTE_PRESENT(&pte)) {
    177199                page_table_unlock(AS, true);
    178200                return ENOENT;
    179201        }
    180202       
    181         *phys = PTE_GET_FRAME(pte) +
     203        *phys = PTE_GET_FRAME(&pte) +
    182204            (virt - ALIGN_DOWN(virt, PAGE_SIZE));
    183205       
Note: See TracChangeset for help on using the changeset viewer.