Changeset 2a2fbc8 in mainline for kernel/generic/src


Ignore:
Timestamp:
2016-09-01T17:05:13Z (9 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
42d08592
Parents:
f126c87 (diff), fb63c06 (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/pt

Location:
kernel/generic/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/ipc/ops/pagein.c

    rf126c87 r2a2fbc8  
    4747{
    4848        if (!IPC_GET_RETVAL(answer->data)) {
    49                 pte_t *pte;
     49                pte_t pte;
    5050                uintptr_t frame;
    5151
    5252                page_table_lock(AS, true);
    53                 pte = page_mapping_find(AS, IPC_GET_ARG1(answer->data), false);
    54                 if (pte) {
    55                         frame = PTE_GET_FRAME(pte);
     53                bool found = page_mapping_find(AS, IPC_GET_ARG1(answer->data),
     54                    false, &pte);
     55                if (found) {
     56                        frame = PTE_GET_FRAME(&pte);
    5657                        pfn_t pfn = ADDR2PFN(frame);
    5758                        if (find_zone(pfn, 1, 0) != (size_t) -1) {

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

    rf126c87 r2a2fbc8  
    889889               
    890890                                for (; i < node_size; i++) {
    891                                         pte_t *pte = page_mapping_find(as,
    892                                             ptr + P2SZ(i), false);
     891                                        pte_t pte;
     892                                        bool found = page_mapping_find(as,
     893                                            ptr + P2SZ(i), false, &pte);
    893894                                       
    894                                         ASSERT(pte);
    895                                         ASSERT(PTE_VALID(pte));
    896                                         ASSERT(PTE_PRESENT(pte));
     895                                        ASSERT(found);
     896                                        ASSERT(PTE_VALID(&pte));
     897                                        ASSERT(PTE_PRESENT(&pte));
    897898                                       
    898899                                        if ((area->backend) &&
    … …  
    900901                                                area->backend->frame_free(area,
    901902                                                    ptr + P2SZ(i),
    902                                                     PTE_GET_FRAME(pte));
     903                                                    PTE_GET_FRAME(&pte));
    903904                                        }
    904905                                       
    … …  
    10031004                       
    10041005                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1005                                 pte_t *pte = page_mapping_find(as,
    1006                                      ptr + P2SZ(size), false);
     1006                                pte_t pte;
     1007                                bool found = page_mapping_find(as,
     1008                                     ptr + P2SZ(size), false, &pte);
    10071009                               
    1008                                 ASSERT(pte);
    1009                                 ASSERT(PTE_VALID(pte));
    1010                                 ASSERT(PTE_PRESENT(pte));
     1010                                ASSERT(found);
     1011                                ASSERT(PTE_VALID(&pte));
     1012                                ASSERT(PTE_PRESENT(&pte));
    10111013                               
    10121014                                if ((area->backend) &&
    … …  
    10141016                                        area->backend->frame_free(area,
    10151017                                            ptr + P2SZ(size),
    1016                                             PTE_GET_FRAME(pte));
     1018                                            PTE_GET_FRAME(&pte));
    10171019                                }
    10181020                               
    … …  
    13151317                       
    13161318                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1317                                 pte_t *pte = page_mapping_find(as,
    1318                                     ptr + P2SZ(size), false);
     1319                                pte_t pte;
     1320                                bool found = page_mapping_find(as,
     1321                                    ptr + P2SZ(size), false, &pte);
    13191322                               
    1320                                 ASSERT(pte);
    1321                                 ASSERT(PTE_VALID(pte));
    1322                                 ASSERT(PTE_PRESENT(pte));
     1323                                ASSERT(found);
     1324                                ASSERT(PTE_VALID(&pte));
     1325                                ASSERT(PTE_PRESENT(&pte));
    13231326                               
    1324                                 old_frame[frame_idx++] = PTE_GET_FRAME(pte);
     1327                                old_frame[frame_idx++] = PTE_GET_FRAME(&pte);
    13251328                               
    13261329                                /* Remove old mapping */
    … …  
    14521455         * we need to make sure the mapping has not been already inserted.
    14531456         */
    1454         pte_t *pte;
    1455         if ((pte = page_mapping_find(AS, page, false))) {
    1456                 if (PTE_PRESENT(pte)) {
    1457                         if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
    1458                             (access == PF_ACCESS_WRITE && PTE_WRITABLE(pte)) ||
    1459                             (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))) {
    14601464                                page_table_unlock(AS, false);
    14611465                                mutex_unlock(&area->lock);

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

    rf126c87 r2a2fbc8  
    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

    rf126c87 r2a2fbc8  
    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

    rf126c87 r2a2fbc8  
    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       

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

    rf126c87 r2a2fbc8  
    291291        spinlock_lock(&futex_ht_lock);
    292292
    293         bool found = false;
    294         pte_t *t = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), true);
    295        
    296         if (t && PTE_VALID(t) && PTE_PRESENT(t)) {
    297                 found = true;
    298                 *paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
     293        bool success = false;
     294
     295        pte_t t;
     296        bool found;
     297
     298        found = page_mapping_find(AS, ALIGN_DOWN(uaddr, PAGE_SIZE), true, &t);
     299        if (found && PTE_VALID(&t) && PTE_PRESENT(&t)) {
     300                success = true;
     301                *paddr = PTE_GET_FRAME(&t) +
     302                    (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
    299303        }
    300304       
    … …  
    302306        page_table_unlock(AS, false);
    303307       
    304         return found;
     308        return success;
    305309}
    306310
Note: See TracChangeset for help on using the changeset viewer.