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

Changeset 98000fb in mainline for kernel/generic/src/mm/as.c


Ignore:
Timestamp:
2009-06-03T19:34:45Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
301ff30
Parents:
69e68e3
Message:

remove redundant index_t and count_t types (which were always quite ambiguous and not actually needed)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/mm/as.c

    r69e68e3 r98000fb  
    419419                        if ((cond = (bool) node->keys)) {
    420420                                uintptr_t b = node->key[node->keys - 1];
    421                                 count_t c =
    422                                     (count_t) node->value[node->keys - 1];
     421                                size_t c =
     422                                    (size_t) node->value[node->keys - 1];
    423423                                unsigned int i = 0;
    424424                       
     
    556556                for (i = 0; i < node->keys; i++) {
    557557                        uintptr_t b = node->key[i];
    558                         count_t j;
     558                        size_t j;
    559559                        pte_t *pte;
    560560                       
    561                         for (j = 0; j < (count_t) node->value[i]; j++) {
     561                        for (j = 0; j < (size_t) node->value[i]; j++) {
    562562                                page_table_lock(as, false);
    563563                                pte = page_mapping_find(as, b + j * PAGE_SIZE);
     
    789789        int page_flags;
    790790        uintptr_t *old_frame;
    791         index_t frame_idx;
    792         count_t used_pages;
     791        size_t frame_idx;
     792        size_t used_pages;
    793793       
    794794        /* Flags for the new memory mapping */
     
    828828                node = list_get_instance(cur, btree_node_t, leaf_link);
    829829                for (i = 0; i < node->keys; i++) {
    830                         used_pages += (count_t) node->value[i];
     830                        used_pages += (size_t) node->value[i];
    831831                }
    832832        }
     
    854854                for (i = 0; i < node->keys; i++) {
    855855                        uintptr_t b = node->key[i];
    856                         count_t j;
     856                        size_t j;
    857857                        pte_t *pte;
    858858                       
    859                         for (j = 0; j < (count_t) node->value[i]; j++) {
     859                        for (j = 0; j < (size_t) node->value[i]; j++) {
    860860                                page_table_lock(as, false);
    861861                                pte = page_mapping_find(as, b + j * PAGE_SIZE);
     
    904904                for (i = 0; i < node->keys; i++) {
    905905                        uintptr_t b = node->key[i];
    906                         count_t j;
     906                        size_t j;
    907907                       
    908                         for (j = 0; j < (count_t) node->value[i]; j++) {
     908                        for (j = 0; j < (size_t) node->value[i]; j++) {
    909909                                page_table_lock(as, false);
    910910
     
    13981398 * @return              Zero on failure and non-zero on success.
    13991399 */
    1400 int used_space_insert(as_area_t *a, uintptr_t page, count_t count)
     1400int used_space_insert(as_area_t *a, uintptr_t page, size_t count)
    14011401{
    14021402        btree_node_t *leaf, *node;
    1403         count_t pages;
     1403        size_t pages;
    14041404        unsigned int i;
    14051405
     
    14071407        ASSERT(count);
    14081408
    1409         pages = (count_t) btree_search(&a->used_space, page, &leaf);
     1409        pages = (size_t) btree_search(&a->used_space, page, &leaf);
    14101410        if (pages) {
    14111411                /*
     
    14241424                uintptr_t left_pg = node->key[node->keys - 1];
    14251425                uintptr_t right_pg = leaf->key[0];
    1426                 count_t left_cnt = (count_t) node->value[node->keys - 1];
    1427                 count_t right_cnt = (count_t) leaf->value[0];
     1426                size_t left_cnt = (size_t) node->value[node->keys - 1];
     1427                size_t right_cnt = (size_t) leaf->value[0];
    14281428               
    14291429                /*
     
    14791479        } else if (page < leaf->key[0]) {
    14801480                uintptr_t right_pg = leaf->key[0];
    1481                 count_t right_cnt = (count_t) leaf->value[0];
     1481                size_t right_cnt = (size_t) leaf->value[0];
    14821482       
    14831483                /*
     
    15141514                uintptr_t left_pg = leaf->key[leaf->keys - 1];
    15151515                uintptr_t right_pg = node->key[0];
    1516                 count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
    1517                 count_t right_cnt = (count_t) node->value[0];
     1516                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
     1517                size_t right_cnt = (size_t) node->value[0];
    15181518               
    15191519                /*
     
    15691569        } else if (page >= leaf->key[leaf->keys - 1]) {
    15701570                uintptr_t left_pg = leaf->key[leaf->keys - 1];
    1571                 count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
     1571                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    15721572       
    15731573                /*
     
    16071607                        uintptr_t left_pg = leaf->key[i - 1];
    16081608                        uintptr_t right_pg = leaf->key[i];
    1609                         count_t left_cnt = (count_t) leaf->value[i - 1];
    1610                         count_t right_cnt = (count_t) leaf->value[i];
     1609                        size_t left_cnt = (size_t) leaf->value[i - 1];
     1610                        size_t right_cnt = (size_t) leaf->value[i];
    16111611
    16121612                        /*
     
    16661666        }
    16671667
    1668         panic("Inconsistency detected while adding %" PRIc " pages of used "
     1668        panic("Inconsistency detected while adding %" PRIs " pages of used "
    16691669            "space at %p.", count, page);
    16701670}
     
    16801680 * @return              Zero on failure and non-zero on success.
    16811681 */
    1682 int used_space_remove(as_area_t *a, uintptr_t page, count_t count)
     1682int used_space_remove(as_area_t *a, uintptr_t page, size_t count)
    16831683{
    16841684        btree_node_t *leaf, *node;
    1685         count_t pages;
     1685        size_t pages;
    16861686        unsigned int i;
    16871687
     
    16891689        ASSERT(count);
    16901690
    1691         pages = (count_t) btree_search(&a->used_space, page, &leaf);
     1691        pages = (size_t) btree_search(&a->used_space, page, &leaf);
    16921692        if (pages) {
    16931693                /*
     
    17181718        if (node && page < leaf->key[0]) {
    17191719                uintptr_t left_pg = node->key[node->keys - 1];
    1720                 count_t left_cnt = (count_t) node->value[node->keys - 1];
     1720                size_t left_cnt = (size_t) node->value[node->keys - 1];
    17211721
    17221722                if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
     
    17341734                        } else if (page + count * PAGE_SIZE <
    17351735                            left_pg + left_cnt*PAGE_SIZE) {
    1736                                 count_t new_cnt;
     1736                                size_t new_cnt;
    17371737                               
    17381738                                /*
     
    17581758        if (page > leaf->key[leaf->keys - 1]) {
    17591759                uintptr_t left_pg = leaf->key[leaf->keys - 1];
    1760                 count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
     1760                size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
    17611761
    17621762                if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
     
    17731773                        } else if (page + count * PAGE_SIZE < left_pg +
    17741774                            left_cnt * PAGE_SIZE) {
    1775                                 count_t new_cnt;
     1775                                size_t new_cnt;
    17761776                               
    17771777                                /*
     
    18001800                if (page < leaf->key[i]) {
    18011801                        uintptr_t left_pg = leaf->key[i - 1];
    1802                         count_t left_cnt = (count_t) leaf->value[i - 1];
     1802                        size_t left_cnt = (size_t) leaf->value[i - 1];
    18031803
    18041804                        /*
     
    18201820                                } else if (page + count * PAGE_SIZE <
    18211821                                    left_pg + left_cnt * PAGE_SIZE) {
    1822                                         count_t new_cnt;
     1822                                        size_t new_cnt;
    18231823                               
    18241824                                        /*
     
    18451845
    18461846error:
    1847         panic("Inconsistency detected while removing %" PRIc " pages of used "
     1847        panic("Inconsistency detected while removing %" PRIs " pages of used "
    18481848            "space from %p.", count, page);
    18491849}
     
    19441944               
    19451945                        mutex_lock(&area->lock);
    1946                         printf("as_area: %p, base=%p, pages=%" PRIc
     1946                        printf("as_area: %p, base=%p, pages=%" PRIs
    19471947                            " (%p - %p)\n", area, area->base, area->pages,
    19481948                            area->base, area->base + FRAMES2SIZE(area->pages));
Note: See TracChangeset for help on using the changeset viewer.