Changeset 2a2fbc8 in mainline for kernel/arch/ia64/src/mm/tlb.c


Ignore:
Timestamp:
2016-09-01T17:05:13Z (8 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

File:
1 edited

Legend:

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

    rf126c87 r2a2fbc8  
    484484{
    485485        uintptr_t va;
    486         pte_t *t;
     486        pte_t t;
    487487       
    488488        va = istate->cr_ifa; /* faulting address */
     
    490490        ASSERT(!is_kernel_fault(va));
    491491
    492         t = page_mapping_find(AS, va, true);
    493         if (t) {
     492        bool found = page_mapping_find(AS, va, true, &t);
     493        if (found) {
    494494                /*
    495495                 * The mapping was found in software page hash table.
    496496                 * Insert it into data translation cache.
    497497                 */
    498                 itc_pte_copy(t);
     498                itc_pte_copy(&t);
    499499        } else {
    500500                /*
     
    600600       
    601601       
    602         pte_t *entry = page_mapping_find(as, va, true);
    603         if (entry) {
     602        pte_t t;
     603        bool found = page_mapping_find(as, va, true, &t);
     604        if (found) {
    604605                /*
    605606                 * The mapping was found in the software page hash table.
    606607                 * Insert it into data translation cache.
    607608                 */
    608                 dtc_pte_copy(entry);
     609                dtc_pte_copy(&t);
    609610        } else {
    610611                if (try_memmap_io_insertion(va, istate))
     
    641642{
    642643        uintptr_t va;
    643         pte_t *t;
     644        pte_t t;
    644645        as_t *as = AS;
    645646       
     
    649650                as = AS_KERNEL;
    650651
    651         t = page_mapping_find(as, va, true);
    652         ASSERT((t) && (t->p));
    653         if ((t) && (t->p) && (t->w)) {
     652        bool found = page_mapping_find(as, va, true, &t);
     653
     654        ASSERT(found);
     655        ASSERT(t.p);
     656
     657        if (found && t.p && t.w) {
    654658                /*
    655659                 * Update the Dirty bit in page tables and reinsert
    656660                 * the mapping into DTC.
    657661                 */
    658                 t->d = true;
    659                 dtc_pte_copy(t);
     662                t.d = true;
     663                dtc_pte_copy(&t);
     664                page_mapping_update(as, va, true, &t);
    660665        } else {
    661666                as_page_fault(va, PF_ACCESS_WRITE, istate);
     
    672677{
    673678        uintptr_t va;
    674         pte_t *t;
     679        pte_t t;
    675680       
    676681        va = istate->cr_ifa;  /* faulting address */
     
    678683        ASSERT(!is_kernel_fault(va));
    679684       
    680         t = page_mapping_find(AS, va, true);
    681         ASSERT((t) && (t->p));
    682         if ((t) && (t->p) && (t->x)) {
     685        bool found = page_mapping_find(AS, va, true, &t);
     686
     687        ASSERT(found);
     688        ASSERT(t.p);
     689
     690        if (found && t.p && t.x) {
    683691                /*
    684692                 * Update the Accessed bit in page tables and reinsert
    685693                 * the mapping into ITC.
    686694                 */
    687                 t->a = true;
    688                 itc_pte_copy(t);
     695                t.a = true;
     696                itc_pte_copy(&t);
     697                page_mapping_update(AS, va, true, &t);
    689698        } else {
    690699                as_page_fault(va, PF_ACCESS_EXEC, istate);
     
    701710{
    702711        uintptr_t va;
    703         pte_t *t;
     712        pte_t t;
    704713        as_t *as = AS;
    705714       
     
    709718                as = AS_KERNEL;
    710719
    711         t = page_mapping_find(as, va, true);
    712         ASSERT((t) && (t->p));
    713         if ((t) && (t->p)) {
     720        bool found = page_mapping_find(as, va, true, &t);
     721
     722        ASSERT(found);
     723        ASSERT(t.p);
     724
     725        if (found && t.p) {
    714726                /*
    715727                 * Update the Accessed bit in page tables and reinsert
    716728                 * the mapping into DTC.
    717729                 */
    718                 t->a = true;
    719                 dtc_pte_copy(t);
     730                t.a = true;
     731                dtc_pte_copy(&t);
     732                page_mapping_update(as, va, true, &t);
    720733        } else {
    721734                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
     
    736749{
    737750        uintptr_t va;
    738         pte_t *t;
     751        pte_t t;
    739752       
    740753        va = istate->cr_ifa;  /* faulting address */
     
    745758         * Assume a write to a read-only page.
    746759         */
    747         t = page_mapping_find(AS, va, true);
    748         ASSERT((t) && (t->p));
    749         ASSERT(!t->w);
     760        bool found = page_mapping_find(AS, va, true, &t);
     761
     762        ASSERT(found);
     763        ASSERT(t.p);
     764        ASSERT(!t.w);
     765
    750766        as_page_fault(va, PF_ACCESS_WRITE, istate);
    751767}
     
    760776{
    761777        uintptr_t va;
    762         pte_t *t;
     778        pte_t t;
    763779       
    764780        va = istate->cr_ifa;  /* faulting address */
     
    766782        ASSERT(!is_kernel_fault(va));
    767783
    768         t = page_mapping_find(AS, va, true);
    769         ASSERT(t);
    770        
    771         if (t->p) {
     784        bool found = page_mapping_find(AS, va, true, &t);
     785
     786        ASSERT(found);
     787       
     788        if (t.p) {
    772789                /*
    773790                 * If the Present bit is set in page hash table, just copy it
    774791                 * and update ITC/DTC.
    775792                 */
    776                 if (t->x)
    777                         itc_pte_copy(t);
     793                if (t.x)
     794                        itc_pte_copy(&t);
    778795                else
    779                         dtc_pte_copy(t);
     796                        dtc_pte_copy(&t);
    780797        } else {
    781798                as_page_fault(va, PF_ACCESS_READ, istate);
Note: See TracChangeset for help on using the changeset viewer.