Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b6f3e7e in mainline


Ignore:
Timestamp:
2011-05-20T22:26:02Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
c263c77
Parents:
712c4ba
Message:

Cleanup. No change in functionality.

Delegate some work to the preprocessor.
Fix including of memstr.h by code in mm/.

Location:
kernel
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/sparc64/src/mm/sun4u/as.c

    r712c4ba rb6f3e7e  
    4747#include <bitops.h>
    4848#include <macros.h>
     49#include <memstr.h>
    4950
    5051#endif /* CONFIG_TSB */
  • kernel/arch/sparc64/src/mm/sun4v/as.c

    r712c4ba rb6f3e7e  
    5050#include <bitops.h>
    5151#include <macros.h>
     52#include <memstr.h>
    5253
    5354#endif /* CONFIG_TSB */
  • kernel/generic/include/mm/page.h

    r712c4ba rb6f3e7e  
    3838#include <typedefs.h>
    3939#include <mm/as.h>
    40 #include <memstr.h>
     40#include <arch/mm/page.h>
     41
     42#define P2SZ(pages) \
     43        ((pages) << PAGE_WIDTH)
    4144
    4245/** Operations to manipulate page mappings. */
  • kernel/generic/src/mm/as.c

    r712c4ba rb6f3e7e  
    302302         * We don't want any area to have conflicts with NULL page.
    303303         */
    304         if (overlaps(addr, count << PAGE_WIDTH, (uintptr_t) NULL, PAGE_SIZE))
     304        if (overlaps(addr, P2SZ(count), (uintptr_t) NULL, PAGE_SIZE))
    305305                return false;
    306306       
     
    329329                        mutex_lock(&area->lock);
    330330                       
    331                         if (overlaps(addr, count << PAGE_WIDTH,
    332                             area->base, area->pages << PAGE_WIDTH)) {
     331                        if (overlaps(addr, P2SZ(count), area->base,
     332                            P2SZ(area->pages))) {
    333333                                mutex_unlock(&area->lock);
    334334                                return false;
     
    346346                        mutex_lock(&area->lock);
    347347                       
    348                         if (overlaps(addr, count << PAGE_WIDTH,
    349                             area->base, area->pages << PAGE_WIDTH)) {
     348                        if (overlaps(addr, P2SZ(count), area->base,
     349                            P2SZ(area->pages))) {
    350350                                mutex_unlock(&area->lock);
    351351                                return false;
     
    366366                mutex_lock(&area->lock);
    367367               
    368                 if (overlaps(addr, count << PAGE_WIDTH,
    369                     area->base, area->pages << PAGE_WIDTH)) {
     368                if (overlaps(addr, P2SZ(count), area->base,
     369                    P2SZ(area->pages))) {
    370370                        mutex_unlock(&area->lock);
    371371                        return false;
     
    380380         */
    381381        if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
    382                 return !overlaps(addr, count << PAGE_WIDTH,
    383                     KERNEL_ADDRESS_SPACE_START,
     382                return !overlaps(addr, P2SZ(count), KERNEL_ADDRESS_SPACE_START,
    384383                    KERNEL_ADDRESS_SPACE_END - KERNEL_ADDRESS_SPACE_START);
    385384        }
     
    474473       
    475474        btree_node_t *leaf;
    476         as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
     475        as_area_t *area = (as_area_t *) btree_search(&as->as_area_btree, va,
     476            &leaf);
    477477        if (area) {
    478478                /* va is the base address of an address space area */
     
    495495                mutex_lock(&area->lock);
    496496
    497                 size_t size = area->pages << PAGE_WIDTH;
    498                 if ((area->base <= va) && (va <= area->base + (size - 1)))
     497                if ((area->base <= va) &&
     498                    (va <= area->base + (P2SZ(area->pages) - 1)))
    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, leaf);
     508        btree_node_t *lnode = btree_leaf_node_left_neighbour(&as->as_area_btree,
     509            leaf);
    509510        if (lnode) {
    510511                area = (as_area_t *) lnode->value[lnode->keys - 1];
     
    512513                mutex_lock(&area->lock);
    513514               
    514                 if (va < area->base + (area->pages << PAGE_WIDTH))
     515                if (va <= area->base + (P2SZ(area->pages) - 1))
    515516                        return area;
    516517               
     
    577578       
    578579        if (pages < area->pages) {
    579                 uintptr_t start_free = area->base + (pages << PAGE_WIDTH);
     580                uintptr_t start_free = area->base + P2SZ(pages);
    580581               
    581582                /*
     
    590591                 */
    591592                ipl_t ipl = tlb_shootdown_start(TLB_INVL_PAGES, as->asid,
    592                     area->base + (pages << PAGE_WIDTH), area->pages - pages);
     593                    area->base + P2SZ(pages), area->pages - pages);
    593594               
    594595                /*
     
    613614                                size_t i = 0;
    614615                               
    615                                 if (overlaps(ptr, size << PAGE_WIDTH, area->base,
    616                                     pages << PAGE_WIDTH)) {
     616                                if (overlaps(ptr, P2SZ(size), area->base,
     617                                    P2SZ(pages))) {
    617618                                       
    618                                         if (ptr + (size << PAGE_WIDTH) <= start_free) {
     619                                        if (ptr + P2SZ(size) <= start_free) {
    619620                                                /*
    620621                                                 * The whole interval fits
     
    647648                               
    648649                                for (; i < size; i++) {
    649                                         pte_t *pte = page_mapping_find(as, ptr +
    650                                             (i << PAGE_WIDTH));
     650                                        pte_t *pte = page_mapping_find(as,
     651                                            ptr + P2SZ(i));
    651652                                       
    652653                                        ASSERT(pte);
     
    657658                                            (area->backend->frame_free)) {
    658659                                                area->backend->frame_free(area,
    659                                                     ptr + (i << PAGE_WIDTH),
     660                                                    ptr + P2SZ(i),
    660661                                                    PTE_GET_FRAME(pte));
    661662                                        }
    662663                                       
    663                                         page_mapping_remove(as, ptr +
    664                                             (i << PAGE_WIDTH));
     664                                        page_mapping_remove(as, ptr + P2SZ(i));
    665665                                }
    666666                        }
     
    671671                 */
    672672               
    673                 tlb_invalidate_pages(as->asid, area->base + (pages << PAGE_WIDTH),
     673                tlb_invalidate_pages(as->asid, area->base + P2SZ(pages),
    674674                    area->pages - pages);
    675675               
     
    677677                 * Invalidate software translation caches (e.g. TSB on sparc64).
    678678                 */
    679                 as_invalidate_translation_cache(as, area->base +
    680                     (pages << PAGE_WIDTH), area->pages - pages);
     679                as_invalidate_translation_cache(as, area->base + P2SZ(pages),
     680                    area->pages - pages);
    681681                tlb_shootdown_finalize(ipl);
    682682               
     
    797797                       
    798798                        for (size = 0; size < (size_t) node->value[i]; size++) {
    799                                 pte_t *pte =
    800                                     page_mapping_find(as, ptr + (size << PAGE_WIDTH));
     799                                pte_t *pte = page_mapping_find(as,
     800                                     ptr + P2SZ(size));
    801801                               
    802802                                ASSERT(pte);
     
    807807                                    (area->backend->frame_free)) {
    808808                                        area->backend->frame_free(area,
    809                                             ptr + (size << PAGE_WIDTH), PTE_GET_FRAME(pte));
     809                                            ptr + P2SZ(size),
     810                                            PTE_GET_FRAME(pte));
    810811                                }
    811812                               
    812                                 page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
     813                                page_mapping_remove(as, ptr + P2SZ(size));
    813814                        }
    814815                }
     
    897898        }
    898899       
    899         size_t src_size = src_area->pages << PAGE_WIDTH;
     900        size_t src_size = P2SZ(src_area->pages);
    900901        unsigned int src_flags = src_area->flags;
    901902        mem_backend_t *src_backend = src_area->backend;
     
    10941095        for (cur = area->used_space.leaf_head.next;
    10951096            cur != &area->used_space.leaf_head; cur = cur->next) {
    1096                 btree_node_t *node
    1097                     = list_get_instance(cur, btree_node_t, leaf_link);
     1097                btree_node_t *node = list_get_instance(cur, btree_node_t,
     1098                    leaf_link);
    10981099                btree_key_t i;
    10991100               
     
    11031104                       
    11041105                        for (size = 0; size < (size_t) node->value[i]; size++) {
    1105                                 pte_t *pte =
    1106                                     page_mapping_find(as, ptr + (size << PAGE_WIDTH));
     1106                                pte_t *pte = page_mapping_find(as,
     1107                                    ptr + P2SZ(size));
    11071108                               
    11081109                                ASSERT(pte);
     
    11131114                               
    11141115                                /* Remove old mapping */
    1115                                 page_mapping_remove(as, ptr + (size << PAGE_WIDTH));
     1116                                page_mapping_remove(as, ptr + P2SZ(size));
    11161117                        }
    11171118                }
     
    11591160                               
    11601161                                /* Insert the new mapping */
    1161                                 page_mapping_insert(as, ptr + (size << PAGE_WIDTH),
     1162                                page_mapping_insert(as, ptr + P2SZ(size),
    11621163                                    old_frame[frame_idx++], page_flags);
    11631164                               
     
    14811482       
    14821483        if (src_area) {
    1483                 size = src_area->pages << PAGE_WIDTH;
     1484                size = P2SZ(src_area->pages);
    14841485                mutex_unlock(&src_area->lock);
    14851486        } else
     
    15361537                if (page >= right_pg) {
    15371538                        /* Do nothing. */
    1538                 } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1539                     left_cnt << PAGE_WIDTH)) {
     1539                } else if (overlaps(page, P2SZ(count), left_pg,
     1540                    P2SZ(left_cnt))) {
    15401541                        /* The interval intersects with the left interval. */
    15411542                        return false;
    1542                 } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1543                     right_cnt << PAGE_WIDTH)) {
     1543                } else if (overlaps(page, P2SZ(count), right_pg,
     1544                    P2SZ(right_cnt))) {
    15441545                        /* The interval intersects with the right interval. */
    15451546                        return false;
    1546                 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1547                     (page + (count << PAGE_WIDTH) == right_pg)) {
     1547                } else if ((page == left_pg + P2SZ(left_cnt)) &&
     1548                    (page + P2SZ(count) == right_pg)) {
    15481549                        /*
    15491550                         * The interval can be added by merging the two already
     
    15531554                        btree_remove(&area->used_space, right_pg, leaf);
    15541555                        goto success;
    1555                 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1556                } else if (page == left_pg + P2SZ(left_cnt)) {
    15561557                        /*
    15571558                         * The interval can be added by simply growing the left
     
    15601561                        node->value[node->keys - 1] += count;
    15611562                        goto success;
    1562                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1563                } else if (page + P2SZ(count) == right_pg) {
    15631564                        /*
    15641565                         * The interval can be addded by simply moving base of
     
    15871588                 */
    15881589               
    1589                 if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1590                     right_cnt << PAGE_WIDTH)) {
     1590                if (overlaps(page, P2SZ(count), right_pg, P2SZ(right_cnt))) {
    15911591                        /* The interval intersects with the right interval. */
    15921592                        return false;
    1593                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1593                } else if (page + P2SZ(count) == right_pg) {
    15941594                        /*
    15951595                         * The interval can be added by moving the base of the
     
    16261626                if (page < left_pg) {
    16271627                        /* Do nothing. */
    1628                 } else if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1629                     left_cnt << PAGE_WIDTH)) {
     1628                } else if (overlaps(page, P2SZ(count), left_pg,
     1629                    P2SZ(left_cnt))) {
    16301630                        /* The interval intersects with the left interval. */
    16311631                        return false;
    1632                 } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1633                     right_cnt << PAGE_WIDTH)) {
     1632                } else if (overlaps(page, P2SZ(count), right_pg,
     1633                    P2SZ(right_cnt))) {
    16341634                        /* The interval intersects with the right interval. */
    16351635                        return false;
    1636                 } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1637                     (page + (count << PAGE_WIDTH) == right_pg)) {
     1636                } else if ((page == left_pg + P2SZ(left_cnt)) &&
     1637                    (page + P2SZ(count) == right_pg)) {
    16381638                        /*
    16391639                         * The interval can be added by merging the two already
     
    16431643                        btree_remove(&area->used_space, right_pg, node);
    16441644                        goto success;
    1645                 } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1645                } else if (page == left_pg + P2SZ(left_cnt)) {
    16461646                        /*
    16471647                         * The interval can be added by simply growing the left
     
    16501650                        leaf->value[leaf->keys - 1] += count;
    16511651                        goto success;
    1652                 } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1652                } else if (page + P2SZ(count) == right_pg) {
    16531653                        /*
    16541654                         * The interval can be addded by simply moving base of
     
    16771677                 */
    16781678               
    1679                 if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1680                     left_cnt << PAGE_WIDTH)) {
     1679                if (overlaps(page, P2SZ(count), left_pg, P2SZ(left_cnt))) {
    16811680                        /* The interval intersects with the left interval. */
    16821681                        return false;
    1683                 } else if (left_pg + (left_cnt << PAGE_WIDTH) == page) {
     1682                } else if (left_pg + P2SZ(left_cnt) == page) {
    16841683                        /*
    16851684                         * The interval can be added by growing the left
     
    17161715                         */
    17171716                       
    1718                         if (overlaps(page, count << PAGE_WIDTH, left_pg,
    1719                             left_cnt << PAGE_WIDTH)) {
     1717                        if (overlaps(page, P2SZ(count), left_pg,
     1718                            P2SZ(left_cnt))) {
    17201719                                /*
    17211720                                 * The interval intersects with the left
     
    17231722                                 */
    17241723                                return false;
    1725                         } else if (overlaps(page, count << PAGE_WIDTH, right_pg,
    1726                             right_cnt << PAGE_WIDTH)) {
     1724                        } else if (overlaps(page, P2SZ(count), right_pg,
     1725                            P2SZ(right_cnt))) {
    17271726                                /*
    17281727                                 * The interval intersects with the right
     
    17301729                                 */
    17311730                                return false;
    1732                         } else if ((page == left_pg + (left_cnt << PAGE_WIDTH)) &&
    1733                             (page + (count << PAGE_WIDTH) == right_pg)) {
     1731                        } else if ((page == left_pg + P2SZ(left_cnt)) &&
     1732                            (page + P2SZ(count) == right_pg)) {
    17341733                                /*
    17351734                                 * The interval can be added by merging the two
     
    17391738                                btree_remove(&area->used_space, right_pg, leaf);
    17401739                                goto success;
    1741                         } else if (page == left_pg + (left_cnt << PAGE_WIDTH)) {
     1740                        } else if (page == left_pg + P2SZ(left_cnt)) {
    17421741                                /*
    17431742                                 * The interval can be added by simply growing
     
    17461745                                leaf->value[i - 1] += count;
    17471746                                goto success;
    1748                         } else if (page + (count << PAGE_WIDTH) == right_pg) {
     1747                        } else if (page + P2SZ(count) == right_pg) {
    17491748                                /*
    17501749                                 * The interval can be addded by simply moving
     
    18121811                        for (i = 0; i < leaf->keys; i++) {
    18131812                                if (leaf->key[i] == page) {
    1814                                         leaf->key[i] += count << PAGE_WIDTH;
     1813                                        leaf->key[i] += P2SZ(count);
    18151814                                        leaf->value[i] -= count;
    18161815                                        goto success;
     
    18221821        }
    18231822       
    1824         btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space, leaf);
     1823        btree_node_t *node = btree_leaf_node_left_neighbour(&area->used_space,
     1824            leaf);
    18251825        if ((node) && (page < leaf->key[0])) {
    18261826                uintptr_t left_pg = node->key[node->keys - 1];
    18271827                size_t left_cnt = (size_t) node->value[node->keys - 1];
    18281828               
    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)) {
     1829                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
     1830                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
    18331831                                /*
    18341832                                 * The interval is contained in the rightmost
     
    18391837                                node->value[node->keys - 1] -= count;
    18401838                                goto success;
    1841                         } else if (page + (count << PAGE_WIDTH) <
    1842                             left_pg + (left_cnt << PAGE_WIDTH)) {
     1839                        } else if (page + P2SZ(count) <
     1840                            left_pg + P2SZ(left_cnt)) {
     1841                                size_t new_cnt;
     1842
    18431843                                /*
    18441844                                 * The interval is contained in the rightmost
     
    18481848                                 * new interval.
    18491849                                 */
    1850                                 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
    1851                                     (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
     1850                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
     1851                                    (page + P2SZ(count))) >> PAGE_WIDTH;
    18521852                                node->value[node->keys - 1] -= count + new_cnt;
    18531853                                btree_insert(&area->used_space, page +
    1854                                     (count << PAGE_WIDTH), (void *) new_cnt, leaf);
     1854                                    P2SZ(count), (void *) new_cnt, leaf);
    18551855                                goto success;
    18561856                        }
     
    18651865                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    18661866               
    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)) {
     1867                if (overlaps(left_pg, P2SZ(left_cnt), page, P2SZ(count))) {
     1868                        if (page + P2SZ(count) == left_pg + P2SZ(left_cnt)) {
    18711869                                /*
    18721870                                 * The interval is contained in the rightmost
     
    18761874                                leaf->value[leaf->keys - 1] -= count;
    18771875                                goto success;
    1878                         } else if (page + (count << PAGE_WIDTH) < left_pg +
    1879                             (left_cnt << PAGE_WIDTH)) {
     1876                        } else if (page + P2SZ(count) < left_pg +
     1877                            P2SZ(left_cnt)) {
     1878                                size_t new_cnt;
     1879
    18801880                                /*
    18811881                                 * The interval is contained in the rightmost
     
    18851885                                 * interval.
    18861886                                 */
    1887                                 size_t new_cnt = ((left_pg + (left_cnt << PAGE_WIDTH)) -
    1888                                     (page + (count << PAGE_WIDTH))) >> PAGE_WIDTH;
     1887                                new_cnt = ((left_pg + P2SZ(left_cnt)) -
     1888                                    (page + P2SZ(count))) >> PAGE_WIDTH;
    18891889                                leaf->value[leaf->keys - 1] -= count + new_cnt;
    18901890                                btree_insert(&area->used_space, page +
    1891                                     (count << PAGE_WIDTH), (void *) new_cnt, leaf);
     1891                                    P2SZ(count), (void *) new_cnt, leaf);
    18921892                                goto success;
    18931893                        }
     
    19111911                         * to (i - 1) and i.
    19121912                         */
    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)) {
     1913                        if (overlaps(left_pg, P2SZ(left_cnt), page,
     1914                            P2SZ(count))) {
     1915                                if (page + P2SZ(count) ==
     1916                                    left_pg + P2SZ(left_cnt)) {
    19171917                                        /*
    19181918                                         * The interval is contained in the
     
    19231923                                        leaf->value[i - 1] -= count;
    19241924                                        goto success;
    1925                                 } else if (page + (count << PAGE_WIDTH) <
    1926                                     left_pg + (left_cnt << PAGE_WIDTH)) {
     1925                                } else if (page + P2SZ(count) <
     1926                                    left_pg + P2SZ(left_cnt)) {
     1927                                        size_t new_cnt;
     1928
    19271929                                        /*
    19281930                                         * The interval is contained in the
     
    19321934                                         * also inserting a new interval.
    19331935                                         */
    1934                                         size_t new_cnt = ((left_pg +
    1935                                             (left_cnt << PAGE_WIDTH)) -
    1936                                             (page + (count << PAGE_WIDTH))) >>
     1936                                        new_cnt = ((left_pg + P2SZ(left_cnt)) -
     1937                                            (page + P2SZ(count))) >>
    19371938                                            PAGE_WIDTH;
    19381939                                        leaf->value[i - 1] -= count + new_cnt;
    19391940                                        btree_insert(&area->used_space, page +
    1940                                             (count << PAGE_WIDTH), (void *) new_cnt,
     1941                                            P2SZ(count), (void *) new_cnt,
    19411942                                            leaf);
    19421943                                        goto success;
     
    20342035                btree_key_t i;
    20352036                for (i = 0; (ret == 0) && (i < node->keys); i++) {
     2037                        uintptr_t addr;
     2038
    20362039                        as_area_t *area = (as_area_t *) node->value[i];
    20372040                       
    20382041                        mutex_lock(&area->lock);
    20392042                       
    2040                         uintptr_t addr =
    2041                             ALIGN_UP(area->base + (area->pages << PAGE_WIDTH),
     2043                        addr = ALIGN_UP(area->base + P2SZ(area->pages),
    20422044                            PAGE_SIZE);
    20432045                       
     
    20982100                       
    20992101                        info[area_idx].start_addr = area->base;
    2100                         info[area_idx].size = FRAMES2SIZE(area->pages);
     2102                        info[area_idx].size = P2SZ(area->pages);
    21012103                        info[area_idx].flags = area->flags;
    21022104                        ++area_idx;
     
    21362138                            " (%p - %p)\n", area, (void *) area->base,
    21372139                            area->pages, (void *) area->base,
    2138                             (void *) (area->base + FRAMES2SIZE(area->pages)));
     2140                            (void *) (area->base + P2SZ(area->pages)));
    21392141                        mutex_unlock(&area->lock);
    21402142                }
  • kernel/generic/src/mm/backend_anon.c

    r712c4ba rb6f3e7e  
    5050#include <typedefs.h>
    5151#include <align.h>
     52#include <memstr.h>
    5253#include <arch.h>
    5354
Note: See TracChangeset for help on using the changeset viewer.