Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    reef1b031 re394b736  
    302302         * We don't want any area to have conflicts with NULL page.
    303303         */
    304         if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE))
     304        if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
    305305                return false;
    306306       
    … …  
    329329                        mutex_lock(&area->lock);
    330330                       
    331                         if (overlaps(addr, P2SZ(count), area->base,
    332                             P2SZ(area->pages))) {
     331                        if (overlaps(addr, count << PAGE_WIDTH,
     332                            area->base, area->pages << PAGE_WIDTH)) {
    333333                                mutex_unlock(&area->lock);
    334334                                return false;
    … …  
    346346                        mutex_lock(&area->lock);
    347347                       
    348                         if (overlaps(addr, P2SZ(count), area->base,
    349                             P2SZ(area->pages))) {
     348                        if (overlaps(addr, count << PAGE_WIDTH,
     349                            area->base, area->pages << PAGE_WIDTH)) {
    350350                                mutex_unlock(&area->lock);
    351351                                return false;
    … …  
    366366                mutex_lock(&area->lock);
    367367               
    368                 if (overlaps(addr, P2SZ(count), area->base,
    369                     P2SZ(area->pages))) {
     368                if (overlaps(addr, count << PAGE_WIDTH,
     369                    area->base, area->pages << PAGE_WIDTH)) {
    370370                        mutex_unlock(&area->lock);
    371371                        return false;
    … …  
    380380         */
    381381        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    382                 return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
     382                return !overlaps(addr, count << PAGE_WIDTH,
     383                    KERNEL_ADDRESS_SPACE_START,
    383384                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
    384385        }
    … …  
    473474       
    474475        btree_node_t *leaf;
    475         as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va,
    476             &leaf);
     476        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
    477477        if (area) {
    478478                /* va is the base address of an address space area */
    … …  
    482482       
    483483        /*
    484          * Search the leaf node and the rightmost record of its left neighbour
     484         * Search the leaf node and the righmost record of its left neighbour
    485485         * to find out whether this is a miss or va belongs to an address
    486486         * space area found there.
    … …  
    494494               
    495495                mutex_lock(&area->lock);
    496 
     496               
    497497                if ((area->base <= va) &&
    498                     (va <= area->base + (P2SZ(area->pages) - 1)))
     498                    (va < area->base + (area->pages << PAGE_WIDTH)))
    499499                        return area;
    500500               
    … …  
    506506         * Because of its position in the B+tree, it must have base < va.
    507507         */
    508         btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree,
    509             leaf);
     508        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf);
    510509        if (lnode) {
    511510                area = (as_area_t *) lnode->value[lnode->keys - 1];
    … …  
    513512                mutex_lock(&area->lock);
    514513               
    515                 if (va <= area->base + (P2SZ(area->pages) - 1))
     514                if (va < area->base + (area->pages << PAGE_WIDTH))
    516515                        return area;
    517516               
    … …  
    578577       
    579578        if (pages < area->pages) {
    580                 uintptr_t start_free = area->base + P2SZ(pages);
     579                uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
    581580               
    582581                /*
    … …  
    591590                 */
    592591                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
    593                     area->base + P2SZ(pages), area->pages - pages);
     592                    area->base + (pages << PAGE_WIDTH), area->pages - pages);
    594593               
    595594                /*
    … …  
    614613                                size_t i = 0;
    615614                               
    616                                 if (overlaps(ptr, P2SZ(size), area->base,
    617                                     P2SZ(pages))) {
     615                                if (overlaps(ptr, size << PAGE_WIDTH, area->base,
     616                                    pages << PAGE_WIDTH)) {
    618617                                       
    619                                         if (ptr + P2SZ(size) <= start_free) {
     618                                        if (ptr + (size << PAGE_WIDTH) <= start_free) {
    620619                                                /*
    621620                                                 * The whole interval fits
    … …  
    648647                               
    649648                                for (; i < size; i++) {
    650                                         pte_t *pte = page_mapping_find(as,
    651                                             ptr + P2SZ(i), false);
     649                                        pte_t *pte = page_mapping_find(as, ptr +
     650                                            (i << PAGE_WIDTH));
    652651                                       
    653652                                        ASSERT(pte);
    … …  
    658657                                            (area->backend->frame_free)) {
    659658                                                area->backend->frame_free(area,
    660                                                     ptr + P2SZ(i),
     659                                                    ptr + (i << PAGE_WIDTH),
    661660                                                    PTE_GET_FRAME(pte));
    662661                                        }
    663662                                       
    664                                         page_mapping_remove(as, ptr + P2SZ(i));
     663                                        page_mapping_remove(as, ptr +
     664                                            (i << PAGE_WIDTH));
    665665                                }
    666666                        }
    … …  
    671671                 */
    672672               
    673                 tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
     673                tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
    674674                    area->pages - pages);
    675675               
    676676                /*
    677                  * Invalidate software translation caches
    678                  * (e.g. TSB on sparc64, PHT on ppc32).
    679                  */
    680                 as_invalidate_translation_cache(as, area->base + P2SZ(pages),
    681                     area->pages - pages);
     677                 * Invalidate software translation caches (e.g. TSB on sparc64).
     678                 */
     679                as_invalidate_translation_cache(as, area->base +
     680                    (pages << PAGE_WIDTH), area->pages - pages);
    682681                tlb_shootdown_finalize(ipl);
    683682               
    … …  
    798797                       
    799798                        for (size = 0; size < (size_t) node->value[i]; size++) {
    800                                 pte_t *pte = page_mapping_find(as,
    801                                      ptr + P2SZ(size), false);
     799                                pte_t *pte =
     800                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
    802801                               
    803802                                ASSERT(pte);
    … …  
    808807                                    (area->backend->frame_free)) {
    809808                                        area->backend->frame_free(area,
    810                                             ptr + P2SZ(size),
    811                                             PTE_GET_FRAME(pte));
     809                                            ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
    812810                                }
    813811                               
    814                                 page_mapping_remove(as, ptr + P2SZ(size));
     812                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
    815813                        }
    816814                }
    … …  
    824822       
    825823        /*
    826          * Invalidate potential software translation caches
    827          * (e.g. TSB on sparc64, PHT on ppc32).
     824         * Invalidate potential software translation caches (e.g. TSB on
     825         * sparc64).
    828826         */
    829827        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    899897        }
    900898       
    901         size_t src_size = P2SZ(src_area->pages);
     899        size_t src_size = src_area->pages << PAGE_WIDTH;
    902900        unsigned int src_flags = src_area->flags;
    903901        mem_backend_t *src_backend = src_area->backend;
    … …  
    10961094        for (cur = area->used_space.leaf_head.next;
    10971095            cur != &area->used_space.leaf_head; cur = cur->next) {
    1098                 btree_node_t *node = list_get_instance(cur, btree_node_t,
    1099                     leaf_link);
     1096                btree_node_t *node
     1097                    = list_get_instance(cur, btree_node_t, leaf_link);
    11001098                btree_key_t i;
    11011099               
    … …  
    11051103                       
    11061104                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1107                                 pte_t *pte = page_mapping_find(as,
    1108                                     ptr + P2SZ(size), false);
     1105                                pte_t *pte =
     1106                                    page_mapping_find(as, ptr + (size << PAGE_WIDTH));
    11091107                               
    11101108                                ASSERT(pte);
    … …  
    11151113                               
    11161114                                /* Remove old mapping */
    1117                                 page_mapping_remove(as, ptr + P2SZ(size));
     1115                                page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
    11181116                        }
    11191117                }
    … …  
    11271125       
    11281126        /*
    1129          * Invalidate potential software translation caches
    1130          * (e.g. TSB on sparc64, PHT on ppc32).
     1127         * Invalidate potential software translation caches (e.g. TSB on
     1128         * sparc64).
    11311129         */
    11321130        as_invalidate_translation_cache(as, area->base, area->pages);
    … …  
    11611159                               
    11621160                                /* Insert the new mapping */
    1163                                 page_mapping_insert(as, ptr + P2SZ(size),
     1161                                page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
    11641162                                    old_frame[frame_idx++], page_flags);
    11651163                               
    … …  
    12421240         */
    12431241        pte_t *pte;
    1244         if ((pte = page_mapping_find(AS, page, false))) {
     1242        if ((pte = page_mapping_find(AS, page))) {
    12451243                if (PTE_PRESENT(pte)) {
    12461244                        if (((access == PF_ACCESS_READ) && PTE_READABLE(pte)) ||
    … …  
    14831481       
    14841482        if (src_area) {
    1485                 size = P2SZ(src_area->pages);
     1483                size = src_area->pages << PAGE_WIDTH;
    14861484                mutex_unlock(&src_area->lock);
    14871485        } else
    … …  
    15381536                if (page >= right_pg) {
    15391537                        /* Do nothing. */
    1540                 } else if (overlaps(page, P2SZ(count), left_pg,
    1541                     P2SZ(left_cnt))) {
     1538                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1539                    left_cnt << PAGE_WIDTH)) {
    15421540                        /* The interval intersects with the left interval. */
    15431541                        return false;
    1544                 } else if (overlaps(page, P2SZ(count), right_pg,
    1545                     P2SZ(right_cnt))) {
     1542                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1543                    right_cnt << PAGE_WIDTH)) {
    15461544                        /* The interval intersects with the right interval. */
    15471545                        return false;
    1548                 } else if ((page == left_pg + P2SZ(left_cnt)) &&
    1549                     (page + P2SZ(count) == right_pg)) {
     1546                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1547                    (page + (count << PAGE_WIDTH) == right_pg)) {
    15501548                        /*
    15511549                         * The interval can be added by merging the two already
    … …  
    15551553                        btree_remove(&area->used_space, right_pg, leaf);
    15561554                        goto success;
    1557                 } else if (page == left_pg + P2SZ(left_cnt)) {
     1555                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    15581556                        /*
    15591557                         * The interval can be added by simply growing the left
    … …  
    15621560                        node->value[node->keys - 1] += count;
    15631561                        goto success;
    1564                 } else if (page + P2SZ(count) == right_pg) {
     1562                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    15651563                        /*
    15661564                         * The interval can be addded by simply moving base of
    … …  
    15891587                 */
    15901588               
    1591                 if (overlaps(page, P2SZ(count), right_pg, P2SZ(right_cnt))) {
     1589                if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1590                    right_cnt << PAGE_WIDTH)) {
    15921591                        /* The interval intersects with the right interval. */
    15931592                        return false;
    1594                 } else if (page + P2SZ(count) == right_pg) {
     1593                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    15951594                        /*
    15961595                         * The interval can be added by moving the base of the
    … …  
    16271626                if (page < left_pg) {
    16281627                        /* Do nothing. */
    1629                 } else if (overlaps(page, P2SZ(count), left_pg,
    1630                     P2SZ(left_cnt))) {
     1628                } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1629                    left_cnt << PAGE_WIDTH)) {
    16311630                        /* The interval intersects with the left interval. */
    16321631                        return false;
    1633                 } else if (overlaps(page, P2SZ(count), right_pg,
    1634                     P2SZ(right_cnt))) {
     1632                } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1633                    right_cnt << PAGE_WIDTH)) {
    16351634                        /* The interval intersects with the right interval. */
    16361635                        return false;
    1637                 } else if ((page == left_pg + P2SZ(left_cnt)) &&
    1638                     (page + P2SZ(count) == right_pg)) {
     1636                } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1637                    (page + (count << PAGE_WIDTH) == right_pg)) {
    16391638                        /*
    16401639                         * The interval can be added by merging the two already
    … …  
    16441643                        btree_remove(&area->used_space, right_pg, node);
    16451644                        goto success;
    1646                 } else if (page == left_pg + P2SZ(left_cnt)) {
     1645                } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    16471646                        /*
    16481647                         * The interval can be added by simply growing the left
    … …  
    16511650                        leaf->value[leaf->keys - 1] += count;
    16521651                        goto success;
    1653                 } else if (page + P2SZ(count) == right_pg) {
     1652                } else if (page + (count << PAGE_WIDTH) == right_pg) {
    16541653                        /*
    16551654                         * The interval can be addded by simply moving base of
    … …  
    16781677                 */
    16791678               
    1680                 if (overlaps(page, P2SZ(count), left_pg, P2SZ(left_cnt))) {
     1679                if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1680                    left_cnt << PAGE_WIDTH)) {
    16811681                        /* The interval intersects with the left interval. */
    16821682                        return false;
    1683                 } else if (left_pg + P2SZ(left_cnt) == page) {
     1683                } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
    16841684                        /*
    16851685                         * The interval can be added by growing the left
    … …  
    17161716                         */
    17171717                       
    1718                         if (overlaps(page, P2SZ(count), left_pg,
    1719                             P2SZ(left_cnt))) {
     1718                        if (overlaps(page, count << PAGE_WIDTH, left_pg,
     1719                            left_cnt << PAGE_WIDTH)) {
    17201720                                /*
    17211721                                 * The interval intersects with the left
    … …  
    17231723                                 */
    17241724                                return false;
    1725                         } else if (overlaps(page, P2SZ(count), right_pg,
    1726                             P2SZ(right_cnt))) {
     1725                        } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
     1726                            right_cnt << PAGE_WIDTH)) {
    17271727                                /*
    17281728                                 * The interval intersects with the right
    … …  
    17301730                                 */
    17311731                                return false;
    1732                         } else if ((page == left_pg + P2SZ(left_cnt)) &&
    1733                             (page + P2SZ(count) == right_pg)) {
     1732                        } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
     1733                            (page + (count << PAGE_WIDTH) == right_pg)) {
    17341734                                /*
    17351735                                 * The interval can be added by merging the two
    … …  
    17391739                                btree_remove(&area->used_space, right_pg, leaf);
    17401740                                goto success;
    1741                         } else if (page == left_pg + P2SZ(left_cnt)) {
     1741                        } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
    17421742                                /*
    17431743                                 * The interval can be added by simply growing
    … …  
    17461746                                leaf->value[i - 1] += count;
    17471747                                goto success;
    1748                         } else if (page + P2SZ(count) == right_pg) {
     1748                        } else if (page + (count << PAGE_WIDTH) == right_pg) {
    17491749                                /*
    17501750                                 * The interval can be addded by simply moving
    … …  
    18121812                        for (i = 0; i < leaf->keys; i++) {
    18131813                                if (leaf->key[i] == page) {
    1814                                         leaf->key[i] += P2SZ(count);
     1814                                        leaf->key[i] += count << PAGE_WIDTH;
    18151815                                        leaf->value[i] -= count;
    18161816                                        goto success;
    … …  
    18221822        }
    18231823       
    1824         btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space,
    1825             leaf);
     1824        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
    18261825        if ((node) && (page < leaf->key[0])) {
    18271826                uintptr_t left_pg = node->key[node->keys - 1];
    18281827                size_t left_cnt = (size_t) node->value[node->keys - 1];
    18291828               
    1830                 if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
    1831                         if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
     1829                if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
     1830                    count << PAGE_WIDTH)) {
     1831                        if (page + (count << PAGE_WIDTH) ==
     1832                            left_pg + (left_cnt << PAGE_WIDTH)) {
    18321833                                /*
    18331834                                 * The interval is contained in the rightmost
    … …  
    18381839                                node->value[node->keys - 1] -= count;
    18391840                                goto success;
    1840                         } else if (page + P2SZ(count) <
    1841                             left_pg + P2SZ(left_cnt)) {
    1842                                 size_t new_cnt;
    1843 
     1841                        } else if (page + (count << PAGE_WIDTH) <
     1842                            left_pg + (left_cnt << PAGE_WIDTH)) {
    18441843                                /*
    18451844                                 * The interval is contained in the rightmost
    … …  
    18491848                                 * new interval.
    18501849                                 */
    1851                                 new_cnt = ((left_pg + P2SZ(left_cnt)) -
    1852                                     (page + P2SZ(count))) >> PAGE_WIDTH;
     1850                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
     1851                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
    18531852                                node->value[node->keys - 1] -= count + new_cnt;
    18541853                                btree_insert(&area->used_space, page +
    1855                                     P2SZ(count), (void *) new_cnt, leaf);
     1854                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
    18561855                                goto success;
    18571856                        }
    … …  
    18661865                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    18671866               
    1868                 if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
    1869                         if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
     1867                if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
     1868                    count << PAGE_WIDTH)) {
     1869                        if (page + (count << PAGE_WIDTH) ==
     1870                            left_pg + (left_cnt << PAGE_WIDTH)) {
    18701871                                /*
    18711872                                 * The interval is contained in the rightmost
    … …  
    18751876                                leaf->value[leaf->keys - 1] -= count;
    18761877                                goto success;
    1877                         } else if (page + P2SZ(count) < left_pg +
    1878                             P2SZ(left_cnt)) {
    1879                                 size_t new_cnt;
    1880 
     1878                        } else if (page + (count << PAGE_WIDTH) < left_pg +
     1879                            (left_cnt << PAGE_WIDTH)) {
    18811880                                /*
    18821881                                 * The interval is contained in the rightmost
    … …  
    18861885                                 * interval.
    18871886                                 */
    1888                                 new_cnt = ((left_pg + P2SZ(left_cnt)) -
    1889                                     (page + P2SZ(count))) >> PAGE_WIDTH;
     1887                                size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
     1888                                    (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
    18901889                                leaf->value[leaf->keys - 1] -= count + new_cnt;
    18911890                                btree_insert(&area->used_space, page +
    1892                                     P2SZ(count), (void *) new_cnt, leaf);
     1891                                    (count << PAGE_WIDTH), (void *) new_cnt, leaf);
    18931892                                goto success;
    18941893                        }
    … …  
    19121911                         * to (i - 1) and i.
    19131912                         */
    1914                         if (overlaps(left_pg, P2SZ(left_cnt), page,
    1915                             P2SZ(count))) {
    1916                                 if (page + P2SZ(count) ==
    1917                                     left_pg + P2SZ(left_cnt)) {
     1913                        if (overlaps(left_pg, left_cnt << PAGE_WIDTH, page,
     1914                            count << PAGE_WIDTH)) {
     1915                                if (page + (count << PAGE_WIDTH) ==
     1916                                    left_pg + (left_cnt << PAGE_WIDTH)) {
    19181917                                        /*
    19191918                                         * The interval is contained in the
    … …  
    19241923                                        leaf->value[i - 1] -= count;
    19251924                                        goto success;
    1926                                 } else if (page + P2SZ(count) <
    1927                                     left_pg + P2SZ(left_cnt)) {
    1928                                         size_t new_cnt;
    1929 
     1925                                } else if (page + (count << PAGE_WIDTH) <
     1926                                    left_pg + (left_cnt << PAGE_WIDTH)) {
    19301927                                        /*
    19311928                                         * The interval is contained in the
    … …  
    19351932                                         * also inserting a new interval.
    19361933                                         */
    1937                                         new_cnt = ((left_pg + P2SZ(left_cnt)) -
    1938                                             (page + P2SZ(count))) >>
     1934                                        size_t new_cnt = ((left_pg +
     1935                                            (left_cnt << PAGE_WIDTH)) -
     1936                                            (page + (count << PAGE_WIDTH))) >>
    19391937                                            PAGE_WIDTH;
    19401938                                        leaf->value[i - 1] -= count + new_cnt;
    19411939                                        btree_insert(&area->used_space, page +
    1942                                             P2SZ(count), (void *) new_cnt,
     1940                                            (count << PAGE_WIDTH), (void *) new_cnt,
    19431941                                            leaf);
    19441942                                        goto success;
    … …  
    20362034                btree_key_t i;
    20372035                for (i = 0; (ret == 0) && (i < node->keys); i++) {
    2038                         uintptr_t addr;
    2039 
    20402036                        as_area_t *area = (as_area_t *) node->value[i];
    20412037                       
    20422038                        mutex_lock(&area->lock);
    20432039                       
    2044                         addr = ALIGN_UP(area->base + P2SZ(area->pages),
     2040                        uintptr_t addr =
     2041                            ALIGN_UP(area->base + (area->pages << PAGE_WIDTH),
    20452042                            PAGE_SIZE);
    20462043                       
    … …  
    21012098                       
    21022099                        info[area_idx].start_addr = area->base;
    2103                         info[area_idx].size = P2SZ(area->pages);
     2100                        info[area_idx].size = FRAMES2SIZE(area->pages);
    21042101                        info[area_idx].flags = area->flags;
    21052102                        ++area_idx;
    … …  
    21392136                            " (%p - %p)\n", area, (void *) area->base,
    21402137                            area->pages, (void *) area->base,
    2141                             (void *) (area->base + P2SZ(area->pages)));
     2138                            (void *) (area->base + FRAMES2SIZE(area->pages)));
    21422139                        mutex_unlock(&area->lock);
    21432140                }
Note: See TracChangeset for help on using the changeset viewer.