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


Ignore:
Timestamp:
2009-06-03T19:34:45Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
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/frame.c

    r69e68e3 r98000fb  
    6868mutex_t mem_avail_mtx;
    6969condvar_t mem_avail_cv;
    70 count_t mem_avail_req = 0;  /**< Number of frames requested. */
    71 count_t mem_avail_gen = 0;  /**< Generation counter. */
     70size_t mem_avail_req = 0;  /**< Number of frames requested. */
     71size_t mem_avail_gen = 0;  /**< Generation counter. */
    7272
    7373/********************/
    … …  
    7575/********************/
    7676
    77 static inline index_t frame_index(zone_t *zone, frame_t *frame)
    78 {
    79         return (index_t) (frame - zone->frames);
    80 }
    81 
    82 static inline index_t frame_index_abs(zone_t *zone, frame_t *frame)
    83 {
    84         return (index_t) (frame - zone->frames) + zone->base;
    85 }
    86 
    87 static inline bool frame_index_valid(zone_t *zone, index_t index)
     77static inline size_t frame_index(zone_t *zone, frame_t *frame)
     78{
     79        return (size_t) (frame - zone->frames);
     80}
     81
     82static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
     83{
     84        return (size_t) (frame - zone->frames) + zone->base;
     85}
     86
     87static inline bool frame_index_valid(zone_t *zone, size_t index)
    8888{
    8989        return (index < zone->count);
    9090}
    9191
    92 static inline index_t make_frame_index(zone_t *zone, frame_t *frame)
     92static inline size_t make_frame_index(zone_t *zone, frame_t *frame)
    9393{
    9494        return (frame - zone->frames);
    … …  
    121121 *
    122122 */
    123 static count_t zones_insert_zone(pfn_t base, count_t count)
     123static size_t zones_insert_zone(pfn_t base, size_t count)
    124124{
    125125        if (zones.count + 1 == ZONES_MAX) {
    126126                printf("Maximum zone count %u exceeded!\n", ZONES_MAX);
    127                 return (count_t) -1;
    128         }
    129        
    130         count_t i;
     127                return (size_t) -1;
     128        }
     129       
     130        size_t i;
    131131        for (i = 0; i < zones.count; i++) {
    132132                /* Check for overlap */
    … …  
    134134                    zones.info[i].base, zones.info[i].count)) {
    135135                        printf("Zones overlap!\n");
    136                         return (count_t) -1;
     136                        return (size_t) -1;
    137137                }
    138138                if (base < zones.info[i].base)
    … …  
    141141       
    142142        /* Move other zones up */
    143         count_t j;
     143        size_t j;
    144144        for (j = zones.count; j > i; j--) {
    145145                zones.info[j] = zones.info[j - 1];
    … …  
    162162 */
    163163#ifdef CONFIG_DEBUG
    164 static count_t total_frames_free(void)
    165 {
    166         count_t total = 0;
    167         count_t i;
     164static size_t total_frames_free(void)
     165{
     166        size_t total = 0;
     167        size_t i;
    168168        for (i = 0; i < zones.count; i++)
    169169                total += zones.info[i].free_count;
    … …  
    185185 *
    186186 */
    187 count_t find_zone(pfn_t frame, count_t count, count_t hint)
     187size_t find_zone(pfn_t frame, size_t count, size_t hint)
    188188{
    189189        if (hint >= zones.count)
    190190                hint = 0;
    191191       
    192         count_t i = hint;
     192        size_t i = hint;
    193193        do {
    194194                if ((zones.info[i].base <= frame)
    … …  
    201201        } while (i != hint);
    202202       
    203         return (count_t) -1;
     203        return (size_t) -1;
    204204}
    205205
    … …  
    221221 *
    222222 */
    223 static count_t find_free_zone(uint8_t order, zone_flags_t flags, count_t hint)
     223static size_t find_free_zone(uint8_t order, zone_flags_t flags, size_t hint)
    224224{
    225225        if (hint >= zones.count)
    226226                hint = 0;
    227227       
    228         count_t i = hint;
     228        size_t i = hint;
    229229        do {
    230230                /*
    … …  
    244244        } while (i != hint);
    245245       
    246         return (count_t) -1;
     246        return (size_t) -1;
    247247}
    248248
    … …  
    266266        zone_t *zone = (zone_t *) buddy->data;
    267267       
    268         index_t index = frame_index(zone, frame);
     268        size_t index = frame_index(zone, frame);
    269269        do {
    270270                if (zone->frames[index].buddy_order != order)
    … …  
    292292        bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
    293293       
    294         index_t index;
     294        size_t index;
    295295        if (is_left) {
    296296                index = (frame_index(zone, frame)) +
    … …  
    447447 *
    448448 */
    449 static void zone_frame_free(zone_t *zone, index_t frame_idx)
     449static void zone_frame_free(zone_t *zone, size_t frame_idx)
    450450{
    451451        ASSERT(zone_flags_available(zone->flags));
    … …  
    468468
    469469/** Return frame from zone. */
    470 static frame_t *zone_get_frame(zone_t *zone, index_t frame_idx)
     470static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
    471471{
    472472        ASSERT(frame_idx < zone->count);
    … …  
    475475
    476476/** Mark frame in zone unavailable to allocation. */
    477 static void zone_mark_unavailable(zone_t *zone, index_t frame_idx)
     477static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
    478478{
    479479        ASSERT(zone_flags_available(zone->flags));
    … …  
    504504 *
    505505 */
    506 static void zone_merge_internal(count_t z1, count_t z2, zone_t *old_z1, buddy_system_t *buddy)
     506static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1, buddy_system_t *buddy)
    507507{
    508508        ASSERT(zone_flags_available(zones.info[z1].flags));
    … …  
    530530       
    531531        /* This marks all frames busy */
    532         count_t i;
     532        size_t i;
    533533        for (i = 0; i < zones.info[z1].count; i++)
    534534                frame_initialize(&zones.info[z1].frames[i]);
    … …  
    600600 *
    601601 */
    602 static void return_config_frames(count_t znum, pfn_t pfn, count_t count)
     602static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
    603603{
    604604        ASSERT(zone_flags_available(zones.info[znum].flags));
    605605       
    606         count_t cframes = SIZE2FRAMES(zone_conf_size(count));
     606        size_t cframes = SIZE2FRAMES(zone_conf_size(count));
    607607       
    608608        if ((pfn < zones.info[znum].base)
    … …  
    615615        ASSERT(!frame->buddy_order);
    616616       
    617         count_t i;
     617        size_t i;
    618618        for (i = 0; i < cframes; i++) {
    619619                zones.info[znum].busy_count++;
    … …  
    635635 *
    636636 */
    637 static void zone_reduce_region(count_t znum, pfn_t frame_idx, count_t count)
     637static void zone_reduce_region(size_t znum, pfn_t frame_idx, size_t count)
    638638{
    639639        ASSERT(zone_flags_available(zones.info[znum].flags));
    … …  
    641641       
    642642        uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;
    643         ASSERT((count_t) (1 << order) >= count);
     643        ASSERT((size_t) (1 << order) >= count);
    644644       
    645645        /* Reduce all blocks to order 0 */
    646         count_t i;
    647         for (i = 0; i < (count_t) (1 << order); i++) {
     646        size_t i;
     647        for (i = 0; i < (size_t) (1 << order); i++) {
    648648                frame_t *frame = &zones.info[znum].frames[i + frame_idx];
    649649                frame->buddy_order = 0;
    … …  
    654654       
    655655        /* Free unneeded frames */
    656         for (i = count; i < (count_t) (1 << order); i++)
     656        for (i = count; i < (size_t) (1 << order); i++)
    657657                zone_frame_free(&zones.info[znum], i + frame_idx);
    658658}
    … …  
    671671 *
    672672 */
    673 bool zone_merge(count_t z1, count_t z2)
     673bool zone_merge(size_t z1, size_t z2)
    674674{
    675675        ipl_t ipl = interrupts_disable();
    … …  
    734734       
    735735        /* Move zones down */
    736         count_t i;
     736        size_t i;
    737737        for (i = z2 + 1; i < zones.count; i++) {
    738738                zones.info[i - 1] = zones.info[i];
    … …  
    759759void zone_merge_all(void)
    760760{
    761         count_t i = 0;
     761        size_t i = 0;
    762762        while (i < zones.count) {
    763763                if (!zone_merge(i, i + 1))
    … …  
    777777 *
    778778 */
    779 static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, count_t count, zone_flags_t flags)
     779static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, size_t count, zone_flags_t flags)
    780780{
    781781        zone->base = start;
    … …  
    800800                    buddy_conf_size(order));
    801801               
    802                 count_t i;
     802                size_t i;
    803803                for (i = 0; i < count; i++)
    804804                        frame_initialize(&zone->frames[i]);
    … …  
    820820 *
    821821 */
    822 uintptr_t zone_conf_size(count_t count)
     822uintptr_t zone_conf_size(size_t count)
    823823{
    824824        return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
    … …  
    841841 *
    842842 */
    843 count_t zone_create(pfn_t start, count_t count, pfn_t confframe, zone_flags_t flags)
     843size_t zone_create(pfn_t start, size_t count, pfn_t confframe, zone_flags_t flags)
    844844{
    845845        ipl_t ipl = interrupts_disable();
    … …  
    856856                 * it does not span kernel & init
    857857                 */
    858                 count_t confcount = SIZE2FRAMES(zone_conf_size(count));
     858                size_t confcount = SIZE2FRAMES(zone_conf_size(count));
    859859                if ((confframe >= start) && (confframe < start + count)) {
    860860                        for (; confframe < start + count; confframe++) {
    … …  
    869869                               
    870870                                bool overlap = false;
    871                                 count_t i;
     871                                size_t i;
    872872                                for (i = 0; i < init.cnt; i++)
    873873                                        if (overlaps(addr, PFN2ADDR(confcount),
    … …  
    887887                }
    888888               
    889                 count_t znum = zones_insert_zone(start, count);
    890                 if (znum == (count_t) -1) {
     889                size_t znum = zones_insert_zone(start, count);
     890                if (znum == (size_t) -1) {
    891891                        spinlock_unlock(&zones.lock);
    892892                        interrupts_restore(ipl);
    893                         return (count_t) -1;
     893                        return (size_t) -1;
    894894                }
    895895               
    … …  
    899899                /* If confdata in zone, mark as unavailable */
    900900                if ((confframe >= start) && (confframe < start + count)) {
    901                         count_t i;
     901                        size_t i;
    902902                        for (i = confframe; i < confframe + confcount; i++)
    903903                                zone_mark_unavailable(&zones.info[znum],
    … …  
    912912       
    913913        /* Non-available zone */
    914         count_t znum = zones_insert_zone(start, count);
    915         if (znum == (count_t) -1) {
     914        size_t znum = zones_insert_zone(start, count);
     915        if (znum == (size_t) -1) {
    916916                spinlock_unlock(&zones.lock);
    917917                interrupts_restore(ipl);
    918                 return (count_t) -1;
     918                return (size_t) -1;
    919919        }
    920920        zone_construct(&zones.info[znum], NULL, start, count, flags);
    … …  
    931931
    932932/** Set parent of frame. */
    933 void frame_set_parent(pfn_t pfn, void *data, count_t hint)
     933void frame_set_parent(pfn_t pfn, void *data, size_t hint)
    934934{
    935935        ipl_t ipl = interrupts_disable();
    936936        spinlock_lock(&zones.lock);
    937937       
    938         count_t znum = find_zone(pfn, 1, hint);
    939        
    940         ASSERT(znum != (count_t) -1);
     938        size_t znum = find_zone(pfn, 1, hint);
     939       
     940        ASSERT(znum != (size_t) -1);
    941941       
    942942        zone_get_frame(&zones.info[znum],
    … …  
    947947}
    948948
    949 void *frame_get_parent(pfn_t pfn, count_t hint)
     949void *frame_get_parent(pfn_t pfn, size_t hint)
    950950{
    951951        ipl_t ipl = interrupts_disable();
    952952        spinlock_lock(&zones.lock);
    953953       
    954         count_t znum = find_zone(pfn, 1, hint);
    955        
    956         ASSERT(znum != (count_t) -1);
     954        size_t znum = find_zone(pfn, 1, hint);
     955       
     956        ASSERT(znum != (size_t) -1);
    957957       
    958958        void *res = zone_get_frame(&zones.info[znum],
    … …  
    974974 *
    975975 */
    976 void *frame_alloc_generic(uint8_t order, frame_flags_t flags, count_t *pzone)
    977 {
    978         count_t size = ((count_t) 1) << order;
     976void *frame_alloc_generic(uint8_t order, frame_flags_t flags, size_t *pzone)
     977{
     978        size_t size = ((size_t) 1) << order;
    979979        ipl_t ipl;
    980         count_t hint = pzone ? (*pzone) : 0;
     980        size_t hint = pzone ? (*pzone) : 0;
    981981       
    982982loop:
    … …  
    987987         * First, find suitable frame zone.
    988988         */
    989         count_t znum = find_free_zone(order,
     989        size_t znum = find_free_zone(order,
    990990            FRAME_TO_ZONE_FLAGS(flags), hint);
    991991       
    992992        /* If no memory, reclaim some slab memory,
    993993           if it does not help, reclaim all */
    994         if ((znum == (count_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
     994        if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
    995995                spinlock_unlock(&zones.lock);
    996996                interrupts_restore(ipl);
    997997               
    998                 count_t freed = slab_reclaim(0);
     998                size_t freed = slab_reclaim(0);
    999999               
    10001000                ipl = interrupts_disable();
    … …  
    10051005                            FRAME_TO_ZONE_FLAGS(flags), hint);
    10061006               
    1007                 if (znum == (count_t) -1) {
     1007                if (znum == (size_t) -1) {
    10081008                        spinlock_unlock(&zones.lock);
    10091009                        interrupts_restore(ipl);
    … …  
    10201020        }
    10211021       
    1022         if (znum == (count_t) -1) {
     1022        if (znum == (size_t) -1) {
    10231023                if (flags & FRAME_ATOMIC) {
    10241024                        spinlock_unlock(&zones.lock);
    … …  
    10281028               
    10291029#ifdef CONFIG_DEBUG
    1030                 count_t avail = total_frames_free();
     1030                size_t avail = total_frames_free();
    10311031#endif
    10321032               
    … …  
    10391039               
    10401040#ifdef CONFIG_DEBUG
    1041                 printf("Thread %" PRIu64 " waiting for %" PRIc " frames, "
    1042                     "%" PRIc " available.\n", THREAD->tid, size, avail);
     1041                printf("Thread %" PRIu64 " waiting for %" PRIs " frames, "
     1042                    "%" PRIs " available.\n", THREAD->tid, size, avail);
    10431043#endif
    10441044               
    … …  
    10491049                else
    10501050                        mem_avail_req = size;
    1051                 count_t gen = mem_avail_gen;
     1051                size_t gen = mem_avail_gen;
    10521052               
    10531053                while (gen == mem_avail_gen)
    … …  
    10961096         */
    10971097        pfn_t pfn = ADDR2PFN(frame);
    1098         count_t znum = find_zone(pfn, 1, NULL);
    1099        
    1100         ASSERT(znum != (count_t) -1);
     1098        size_t znum = find_zone(pfn, 1, NULL);
     1099       
     1100        ASSERT(znum != (size_t) -1);
    11011101       
    11021102        zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
    … …  
    11351135         * First, find host frame zone for addr.
    11361136         */
    1137         count_t znum = find_zone(pfn, 1, NULL);
    1138        
    1139         ASSERT(znum != (count_t) -1);
     1137        size_t znum = find_zone(pfn, 1, NULL);
     1138       
     1139        ASSERT(znum != (size_t) -1);
    11401140       
    11411141        zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
    … …  
    11461146
    11471147/** Mark given range unavailable in frame zones. */
    1148 void frame_mark_unavailable(pfn_t start, count_t count)
     1148void frame_mark_unavailable(pfn_t start, size_t count)
    11491149{
    11501150        ipl_t ipl = interrupts_disable();
    11511151        spinlock_lock(&zones.lock);
    11521152       
    1153         count_t i;
     1153        size_t i;
    11541154        for (i = 0; i < count; i++) {
    1155                 count_t znum = find_zone(start + i, 1, 0);
    1156                 if (znum == (count_t) -1)  /* PFN not found */
     1155                size_t znum = find_zone(start + i, 1, 0);
     1156                if (znum == (size_t) -1)  /* PFN not found */
    11571157                        continue;
    11581158               
    … …  
    11831183                    SIZE2FRAMES(config.stack_size));
    11841184               
    1185                 count_t i;
     1185                size_t i;
    11861186                for (i = 0; i < init.cnt; i++) {
    11871187                        pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr));
    … …  
    12081208       
    12091209        uint64_t total = 0;
    1210         count_t i;
     1210        size_t i;
    12111211        for (i = 0; i < zones.count; i++)
    12121212                total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
    … …  
    12421242         */
    12431243       
    1244         count_t i;
     1244        size_t i;
    12451245        for (i = 0;; i++) {
    12461246                ipl_t ipl = interrupts_disable();
    … …  
    12541254               
    12551255                uintptr_t base = PFN2ADDR(zones.info[i].base);
    1256                 count_t count = zones.info[i].count;
     1256                size_t count = zones.info[i].count;
    12571257                zone_flags_t flags = zones.info[i].flags;
    1258                 count_t free_count = zones.info[i].free_count;
    1259                 count_t busy_count = zones.info[i].busy_count;
     1258                size_t free_count = zones.info[i].free_count;
     1259                size_t busy_count = zones.info[i].busy_count;
    12601260               
    12611261                spinlock_unlock(&zones.lock);
    … …  
    12641264                bool available = zone_flags_available(flags);
    12651265               
    1266                 printf("%-2" PRIc, i);
     1266                printf("%-2" PRIs, i);
    12671267               
    12681268#ifdef __32_BITS__
    … …  
    12741274#endif
    12751275               
    1276                 printf(" %12" PRIc " %c%c%c      ", count,
     1276                printf(" %12" PRIs " %c%c%c      ", count,
    12771277                    available ? 'A' : ' ',
    12781278                    (flags & ZONE_RESERVED) ? 'R' : ' ',
    … …  
    12801280               
    12811281                if (available)
    1282                         printf("%12" PRIc " %12" PRIc,
     1282                        printf("%12" PRIs " %12" PRIs,
    12831283                            free_count, busy_count);
    12841284               
    … …  
    12921292 *
    12931293 */
    1294 void zone_print_one(count_t num)
     1294void zone_print_one(size_t num)
    12951295{
    12961296        ipl_t ipl = interrupts_disable();
    12971297        spinlock_lock(&zones.lock);
    1298         count_t znum = (count_t) -1;
    1299        
    1300         count_t i;
     1298        size_t znum = (size_t) -1;
     1299       
     1300        size_t i;
    13011301        for (i = 0; i < zones.count; i++) {
    13021302                if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) {
    … …  
    13061306        }
    13071307       
    1308         if (znum == (count_t) -1) {
     1308        if (znum == (size_t) -1) {
    13091309                spinlock_unlock(&zones.lock);
    13101310                interrupts_restore(ipl);
    … …  
    13151315        uintptr_t base = PFN2ADDR(zones.info[i].base);
    13161316        zone_flags_t flags = zones.info[i].flags;
    1317         count_t count = zones.info[i].count;
    1318         count_t free_count = zones.info[i].free_count;
    1319         count_t busy_count = zones.info[i].busy_count;
     1317        size_t count = zones.info[i].count;
     1318        size_t free_count = zones.info[i].free_count;
     1319        size_t busy_count = zones.info[i].busy_count;
    13201320       
    13211321        spinlock_unlock(&zones.lock);
    … …  
    13241324        bool available = zone_flags_available(flags);
    13251325       
    1326         printf("Zone number:       %" PRIc "\n", znum);
     1326        printf("Zone number:       %" PRIs "\n", znum);
    13271327        printf("Zone base address: %p\n", base);
    1328         printf("Zone size:         %" PRIc " frames (%" PRIs " KiB)\n", count,
     1328        printf("Zone size:         %" PRIs " frames (%" PRIs " KiB)\n", count,
    13291329            SIZE2KB(FRAMES2SIZE(count)));
    13301330        printf("Zone flags:        %c%c%c\n",
    … …  
    13341334       
    13351335        if (available) {
    1336                 printf("Allocated space:   %" PRIc " frames (%" PRIs " KiB)\n",
     1336                printf("Allocated space:   %" PRIs " frames (%" PRIs " KiB)\n",
    13371337                    busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
    1338                 printf("Available space:   %" PRIc " frames (%" PRIs " KiB)\n",
     1338                printf("Available space:   %" PRIs " frames (%" PRIs " KiB)\n",
    13391339                    free_count, SIZE2KB(FRAMES2SIZE(free_count)));
    13401340        }
Note: See TracChangeset for help on using the changeset viewer.