Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r98000fb r7e752b2  
    4343 */
    4444
    45 #include <arch/types.h>
     45#include <typedefs.h>
    4646#include <mm/frame.h>
    4747#include <mm/as.h>
    … …  
    6666 * available.
    6767 */
    68 mutex_t mem_avail_mtx;
    69 condvar_t mem_avail_cv;
    70 size_t mem_avail_req = 0;  /**< Number of frames requested. */
    71 size_t mem_avail_gen = 0;  /**< Generation counter. */
     68static mutex_t mem_avail_mtx;
     69static condvar_t mem_avail_cv;
     70static size_t mem_avail_req = 0;  /**< Number of frames requested. */
     71static size_t mem_avail_gen = 0;  /**< Generation counter. */
    7272
    7373/********************/
    … …  
    7575/********************/
    7676
    77 static inline size_t frame_index(zone_t *zone, frame_t *frame)
     77NO_TRACE static inline size_t frame_index(zone_t *zone, frame_t *frame)
    7878{
    7979        return (size_t) (frame - zone->frames);
    8080}
    8181
    82 static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
     82NO_TRACE static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
    8383{
    8484        return (size_t) (frame - zone->frames) + zone->base;
    8585}
    8686
    87 static inline bool frame_index_valid(zone_t *zone, size_t index)
     87NO_TRACE static inline bool frame_index_valid(zone_t *zone, size_t index)
    8888{
    8989        return (index < zone->count);
    9090}
    9191
    92 static inline size_t make_frame_index(zone_t *zone, frame_t *frame)
     92NO_TRACE static inline size_t make_frame_index(zone_t *zone, frame_t *frame)
    9393{
    9494        return (frame - zone->frames);
    … …  
    100100 *
    101101 */
    102 static void frame_initialize(frame_t *frame)
     102NO_TRACE static void frame_initialize(frame_t *frame)
    103103{
    104104        frame->refcount = 1;
    … …  
    121121 *
    122122 */
    123 static size_t zones_insert_zone(pfn_t base, size_t count)
     123NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count,
     124    zone_flags_t flags)
    124125{
    125126        if (zones.count + 1 == ZONES_MAX) {
    … …  
    131132        for (i = 0; i < zones.count; i++) {
    132133                /* Check for overlap */
    133                 if (overlaps(base, count,
    134                     zones.info[i].base, zones.info[i].count)) {
    135                         printf("Zones overlap!\n");
     134                if (overlaps(zones.info[i].base, zones.info[i].count,
     135                    base, count)) {
     136                       
     137                        /*
     138                         * If the overlaping zones are of the same type
     139                         * and the new zone is completely within the previous
     140                         * one, then quietly ignore the new zone.
     141                         *
     142                         */
     143                       
     144                        if ((zones.info[i].flags != flags) ||
     145                            (!iswithin(zones.info[i].base, zones.info[i].count,
     146                            base, count))) {
     147                                printf("Zone (%p, %p) overlaps "
     148                                    "with previous zone (%p %p)!\n",
     149                                    (void *) PFN2ADDR(base), (void *) PFN2ADDR(count),
     150                                    (void *) PFN2ADDR(zones.info[i].base),
     151                                    (void *) PFN2ADDR(zones.info[i].count));
     152                        }
     153                       
    136154                        return (size_t) -1;
    137155                }
    … …  
    144162        for (j = zones.count; j > i; j--) {
    145163                zones.info[j] = zones.info[j - 1];
    146                 zones.info[j].buddy_system->data =
    147                     (void *) &zones.info[j - 1];
     164                if (zones.info[j].buddy_system != NULL)
     165                        zones.info[j].buddy_system->data =
     166                            (void *) &zones.info[j];
    148167        }
    149168       
    … …  
    162181 */
    163182#ifdef CONFIG_DEBUG
    164 static size_t total_frames_free(void)
     183NO_TRACE static size_t total_frames_free(void)
    165184{
    166185        size_t total = 0;
    … …  
    171190        return total;
    172191}
    173 #endif
     192#endif /* CONFIG_DEBUG */
    174193
    175194/** Find a zone with a given frames.
    … …  
    185204 *
    186205 */
    187 size_t find_zone(pfn_t frame, size_t count, size_t hint)
     206NO_TRACE size_t find_zone(pfn_t frame, size_t count, size_t hint)
    188207{
    189208        if (hint >= zones.count)
    … …  
    199218                if (i >= zones.count)
    200219                        i = 0;
     220               
    201221        } while (i != hint);
    202222       
    … …  
    205225
    206226/** @return True if zone can allocate specified order */
    207 static bool zone_can_alloc(zone_t *zone, uint8_t order)
     227NO_TRACE static bool zone_can_alloc(zone_t *zone, uint8_t order)
    208228{
    209229        return (zone_flags_available(zone->flags)
    … …  
    221241 *
    222242 */
    223 static size_t find_free_zone(uint8_t order, zone_flags_t flags, size_t hint)
     243NO_TRACE static size_t find_free_zone(uint8_t order, zone_flags_t flags,
     244    size_t hint)
    224245{
    225246        if (hint >= zones.count)
    … …  
    242263                if (i >= zones.count)
    243264                        i = 0;
     265               
    244266        } while (i != hint);
    245267       
    … …  
    260282 *
    261283 */
    262 static link_t *zone_buddy_find_block(buddy_system_t *buddy, link_t *child,
    263     uint8_t order)
     284NO_TRACE static link_t *zone_buddy_find_block(buddy_system_t *buddy,
     285    link_t *child, uint8_t order)
    264286{
    265287        frame_t *frame = list_get_instance(child, frame_t, buddy_link);
    … …  
    283305 *
    284306 */
    285 static link_t *zone_buddy_find_buddy(buddy_system_t *buddy, link_t *block)
     307NO_TRACE static link_t *zone_buddy_find_buddy(buddy_system_t *buddy,
     308    link_t *block)
    286309{
    287310        frame_t *frame = list_get_instance(block, frame_t, buddy_link);
    … …  
    296319                index = (frame_index(zone, frame)) +
    297320                    (1 << frame->buddy_order);
    298         } else {        /* is_right */
     321        } else {  /* is_right */
    299322                index = (frame_index(zone, frame)) -
    300323                    (1 << frame->buddy_order);
    … …  
    319342 *
    320343 */
    321 static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
     344NO_TRACE static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
    322345{
    323346        frame_t *frame_l = list_get_instance(block, frame_t, buddy_link);
    … …  
    337360 *
    338361 */
    339 static link_t *zone_buddy_coalesce(buddy_system_t *buddy, link_t *block_1,
    340     link_t *block_2)
     362NO_TRACE static link_t *zone_buddy_coalesce(buddy_system_t *buddy,
     363    link_t *block_1, link_t *block_2)
    341364{
    342365        frame_t *frame1 = list_get_instance(block_1, frame_t, buddy_link);
    … …  
    353376 *
    354377 */
    355 static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
     378NO_TRACE static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
    356379    uint8_t order)
    357380{
    … …  
    367390 *
    368391 */
    369 static uint8_t zone_buddy_get_order(buddy_system_t *buddy, link_t *block)
     392NO_TRACE static uint8_t zone_buddy_get_order(buddy_system_t *buddy,
     393    link_t *block)
    370394{
    371395        return list_get_instance(block, frame_t, buddy_link)->buddy_order;
    … …  
    378402 *
    379403 */
    380 static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t * block)
     404NO_TRACE static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t *block)
    381405{
    382406        list_get_instance(block, frame_t, buddy_link)->refcount = 1;
    … …  
    387411 * @param buddy Buddy system.
    388412 * @param block Buddy system block.
    389  */
    390 static void zone_buddy_mark_available(buddy_system_t *buddy, link_t *block)
     413 *
     414 */
     415NO_TRACE static void zone_buddy_mark_available(buddy_system_t *buddy,
     416    link_t *block)
    391417{
    392418        list_get_instance(block, frame_t, buddy_link)->refcount = 0;
    … …  
    419445 *
    420446 */
    421 static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
     447NO_TRACE static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
    422448{
    423449        ASSERT(zone_flags_available(zone->flags));
    … …  
    447473 *
    448474 */
    449 static void zone_frame_free(zone_t *zone, size_t frame_idx)
     475NO_TRACE static void zone_frame_free(zone_t *zone, size_t frame_idx)
    450476{
    451477        ASSERT(zone_flags_available(zone->flags));
    … …  
    468494
    469495/** Return frame from zone. */
    470 static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
     496NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
    471497{
    472498        ASSERT(frame_idx < zone->count);
    … …  
    475501
    476502/** Mark frame in zone unavailable to allocation. */
    477 static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
     503NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
    478504{
    479505        ASSERT(zone_flags_available(zone->flags));
    … …  
    504530 *
    505531 */
    506 static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1, buddy_system_t *buddy)
     532NO_TRACE static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1,
     533    buddy_system_t *buddy)
    507534{
    508535        ASSERT(zone_flags_available(zones.info[z1].flags));
    … …  
    600627 *
    601628 */
    602 static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
     629NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
    603630{
    604631        ASSERT(zone_flags_available(zones.info[znum].flags));
    … …  
    635662 *
    636663 */
    637 static void zone_reduce_region(size_t znum, pfn_t frame_idx, size_t count)
     664NO_TRACE static void zone_reduce_region(size_t znum, pfn_t frame_idx,
     665    size_t count)
    638666{
    639667        ASSERT(zone_flags_available(zones.info[znum].flags));
    … …  
    673701bool zone_merge(size_t z1, size_t z2)
    674702{
    675         ipl_t ipl = interrupts_disable();
    676         spinlock_lock(&zones.lock);
     703        irq_spinlock_lock(&zones.lock, true);
    677704       
    678705        bool ret = true;
    … …  
    737764        for (i = z2 + 1; i < zones.count; i++) {
    738765                zones.info[i - 1] = zones.info[i];
    739                 zones.info[i - 1].buddy_system->data =
    740                     (void *) &zones.info[i - 1];
     766                if (zones.info[i - 1].buddy_system != NULL)
     767                        zones.info[i - 1].buddy_system->data =
     768                            (void *) &zones.info[i - 1];
    741769        }
    742770       
    … …  
    744772       
    745773errout:
    746         spinlock_unlock(&zones.lock);
    747         interrupts_restore(ipl);
     774        irq_spinlock_unlock(&zones.lock, true);
    748775       
    749776        return ret;
    … …  
    777804 *
    778805 */
    779 static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, size_t count, zone_flags_t flags)
     806NO_TRACE static void zone_construct(zone_t *zone, buddy_system_t *buddy,
     807    pfn_t start, size_t count, zone_flags_t flags)
    780808{
    781809        zone->base = start;
    … …  
    820848 *
    821849 */
    822 uintptr_t zone_conf_size(size_t count)
     850size_t zone_conf_size(size_t count)
    823851{
    824852        return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
    … …  
    841869 *
    842870 */
    843 size_t zone_create(pfn_t start, size_t count, pfn_t confframe, zone_flags_t flags)
    844 {
    845         ipl_t ipl = interrupts_disable();
    846         spinlock_lock(&zones.lock);
     871size_t zone_create(pfn_t start, size_t count, pfn_t confframe,
     872    zone_flags_t flags)
     873{
     874        irq_spinlock_lock(&zones.lock, true);
    847875       
    848876        if (zone_flags_available(flags)) {  /* Create available zone */
    … …  
    851879                 * the assert
    852880                 */
    853                 ASSERT(confframe != NULL);
     881                ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
    854882               
    855883                /* If confframe is supposed to be inside our zone, then make sure
    … …  
    887915                }
    888916               
    889                 size_t znum = zones_insert_zone(start, count);
     917                size_t znum = zones_insert_zone(start, count, flags);
    890918                if (znum == (size_t) -1) {
    891                         spinlock_unlock(&zones.lock);
    892                         interrupts_restore(ipl);
     919                        irq_spinlock_unlock(&zones.lock, true);
    893920                        return (size_t) -1;
    894921                }
    … …  
    905932                }
    906933               
    907                 spinlock_unlock(&zones.lock);
    908                 interrupts_restore(ipl);
     934                irq_spinlock_unlock(&zones.lock, true);
    909935               
    910936                return znum;
    … …  
    912938       
    913939        /* Non-available zone */
    914         size_t znum = zones_insert_zone(start, count);
     940        size_t znum = zones_insert_zone(start, count, flags);
    915941        if (znum == (size_t) -1) {
    916                 spinlock_unlock(&zones.lock);
    917                 interrupts_restore(ipl);
     942                irq_spinlock_unlock(&zones.lock, true);
    918943                return (size_t) -1;
    919944        }
    920945        zone_construct(&zones.info[znum], NULL, start, count, flags);
    921946       
    922         spinlock_unlock(&zones.lock);
    923         interrupts_restore(ipl);
     947        irq_spinlock_unlock(&zones.lock, true);
    924948       
    925949        return znum;
    … …  
    933957void frame_set_parent(pfn_t pfn, void *data, size_t hint)
    934958{
    935         ipl_t ipl = interrupts_disable();
    936         spinlock_lock(&zones.lock);
     959        irq_spinlock_lock(&zones.lock, true);
    937960       
    938961        size_t znum = find_zone(pfn, 1, hint);
    … …  
    943966            pfn - zones.info[znum].base)->parent = data;
    944967       
    945         spinlock_unlock(&zones.lock);
    946         interrupts_restore(ipl);
     968        irq_spinlock_unlock(&zones.lock, true);
    947969}
    948970
    949971void *frame_get_parent(pfn_t pfn, size_t hint)
    950972{
    951         ipl_t ipl = interrupts_disable();
    952         spinlock_lock(&zones.lock);
     973        irq_spinlock_lock(&zones.lock, true);
    953974       
    954975        size_t znum = find_zone(pfn, 1, hint);
    … …  
    959980            pfn - zones.info[znum].base)->parent;
    960981       
    961         spinlock_unlock(&zones.lock);
    962         interrupts_restore(ipl);
     982        irq_spinlock_unlock(&zones.lock, true);
    963983       
    964984        return res;
    … …  
    977997{
    978998        size_t size = ((size_t) 1) << order;
    979         ipl_t ipl;
    980999        size_t hint = pzone ? (*pzone) : 0;
    9811000       
    9821001loop:
    983         ipl = interrupts_disable();
    984         spinlock_lock(&zones.lock);
     1002        irq_spinlock_lock(&zones.lock, true);
    9851003       
    9861004        /*
    … …  
    9931011           if it does not help, reclaim all */
    9941012        if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
    995                 spinlock_unlock(&zones.lock);
    996                 interrupts_restore(ipl);
    997                
     1013                irq_spinlock_unlock(&zones.lock, true);
    9981014                size_t freed = slab_reclaim(0);
    999                
    1000                 ipl = interrupts_disable();
    1001                 spinlock_lock(&zones.lock);
     1015                irq_spinlock_lock(&zones.lock, true);
    10021016               
    10031017                if (freed > 0)
    … …  
    10061020               
    10071021                if (znum == (size_t) -1) {
    1008                         spinlock_unlock(&zones.lock);
    1009                         interrupts_restore(ipl);
    1010                        
     1022                        irq_spinlock_unlock(&zones.lock, true);
    10111023                        freed = slab_reclaim(SLAB_RECLAIM_ALL);
    1012                        
    1013                         ipl = interrupts_disable();
    1014                         spinlock_lock(&zones.lock);
     1024                        irq_spinlock_lock(&zones.lock, true);
    10151025                       
    10161026                        if (freed > 0)
    … …  
    10221032        if (znum == (size_t) -1) {
    10231033                if (flags & FRAME_ATOMIC) {
    1024                         spinlock_unlock(&zones.lock);
    1025                         interrupts_restore(ipl);
     1034                        irq_spinlock_unlock(&zones.lock, true);
    10261035                        return NULL;
    10271036                }
    … …  
    10311040#endif
    10321041               
    1033                 spinlock_unlock(&zones.lock);
    1034                 interrupts_restore(ipl);
     1042                irq_spinlock_unlock(&zones.lock, true);
     1043               
     1044                if (!THREAD)
     1045                        panic("Cannot wait for memory to become available.");
    10351046               
    10361047                /*
    … …  
    10391050               
    10401051#ifdef CONFIG_DEBUG
    1041                 printf("Thread %" PRIu64 " waiting for %" PRIs " frames, "
    1042                     "%" PRIs " available.\n", THREAD->tid, size, avail);
     1052                printf("Thread %" PRIu64 " waiting for %zu frames, "
     1053                    "%zu available.\n", THREAD->tid, size, avail);
    10431054#endif
    10441055               
    … …  
    10661077            + zones.info[znum].base;
    10671078       
    1068         spinlock_unlock(&zones.lock);
    1069         interrupts_restore(ipl);
     1079        irq_spinlock_unlock(&zones.lock, true);
    10701080       
    10711081        if (pzone)
    … …  
    10891099void frame_free(uintptr_t frame)
    10901100{
    1091         ipl_t ipl = interrupts_disable();
    1092         spinlock_lock(&zones.lock);
     1101        irq_spinlock_lock(&zones.lock, true);
    10931102       
    10941103        /*
    … …  
    10961105         */
    10971106        pfn_t pfn = ADDR2PFN(frame);
    1098         size_t znum = find_zone(pfn, 1, NULL);
     1107        size_t znum = find_zone(pfn, 1, 0);
    10991108       
    11001109        ASSERT(znum != (size_t) -1);
    … …  
    11021111        zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
    11031112       
    1104         spinlock_unlock(&zones.lock);
    1105         interrupts_restore(ipl);
     1113        irq_spinlock_unlock(&zones.lock, true);
    11061114       
    11071115        /*
    … …  
    11271135 *
    11281136 */
    1129 void frame_reference_add(pfn_t pfn)
    1130 {
    1131         ipl_t ipl = interrupts_disable();
    1132         spinlock_lock(&zones.lock);
     1137NO_TRACE void frame_reference_add(pfn_t pfn)
     1138{
     1139        irq_spinlock_lock(&zones.lock, true);
    11331140       
    11341141        /*
    11351142         * First, find host frame zone for addr.
    11361143         */
    1137         size_t znum = find_zone(pfn, 1, NULL);
     1144        size_t znum = find_zone(pfn, 1, 0);
    11381145       
    11391146        ASSERT(znum != (size_t) -1);
    … …  
    11411148        zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
    11421149       
    1143         spinlock_unlock(&zones.lock);
    1144         interrupts_restore(ipl);
    1145 }
    1146 
    1147 /** Mark given range unavailable in frame zones. */
    1148 void frame_mark_unavailable(pfn_t start, size_t count)
    1149 {
    1150         ipl_t ipl = interrupts_disable();
    1151         spinlock_lock(&zones.lock);
     1150        irq_spinlock_unlock(&zones.lock, true);
     1151}
     1152
     1153/** Mark given range unavailable in frame zones.
     1154 *
     1155 */
     1156NO_TRACE void frame_mark_unavailable(pfn_t start, size_t count)
     1157{
     1158        irq_spinlock_lock(&zones.lock, true);
    11521159       
    11531160        size_t i;
    … …  
    11611168        }
    11621169       
    1163         spinlock_unlock(&zones.lock);
    1164         interrupts_restore(ipl);
    1165 }
    1166 
    1167 /** Initialize physical memory management. */
     1170        irq_spinlock_unlock(&zones.lock, true);
     1171}
     1172
     1173/** Initialize physical memory management.
     1174 *
     1175 */
    11681176void frame_init(void)
    11691177{
    11701178        if (config.cpu_active == 1) {
    11711179                zones.count = 0;
    1172                 spinlock_initialize(&zones.lock, "zones.lock");
     1180                irq_spinlock_initialize(&zones.lock, "frame.zones.lock");
    11731181                mutex_initialize(&mem_avail_mtx, MUTEX_ACTIVE);
    11741182                condvar_initialize(&mem_avail_cv);
    … …  
    12011209}
    12021210
    1203 /** Return total size of all zones. */
    1204 uint64_t zone_total_size(void)
    1205 {
    1206         ipl_t ipl = interrupts_disable();
    1207         spinlock_lock(&zones.lock);
     1211/** Return total size of all zones.
     1212 *
     1213 */
     1214uint64_t zones_total_size(void)
     1215{
     1216        irq_spinlock_lock(&zones.lock, true);
    12081217       
    12091218        uint64_t total = 0;
    … …  
    12121221                total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
    12131222       
    1214         spinlock_unlock(&zones.lock);
    1215         interrupts_restore(ipl);
     1223        irq_spinlock_unlock(&zones.lock, true);
    12161224       
    12171225        return total;
    12181226}
    12191227
    1220 /** Prints list of zones. */
    1221 void zone_print_list(void)
     1228void zones_stats(uint64_t *total, uint64_t *unavail, uint64_t *busy,
     1229    uint64_t *free)
     1230{
     1231        ASSERT(total != NULL);
     1232        ASSERT(unavail != NULL);
     1233        ASSERT(busy != NULL);
     1234        ASSERT(free != NULL);
     1235       
     1236        irq_spinlock_lock(&zones.lock, true);
     1237       
     1238        *total = 0;
     1239        *unavail = 0;
     1240        *busy = 0;
     1241        *free = 0;
     1242       
     1243        size_t i;
     1244        for (i = 0; i < zones.count; i++) {
     1245                *total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
     1246               
     1247                if (zone_flags_available(zones.info[i].flags)) {
     1248                        *busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
     1249                        *free += (uint64_t) FRAMES2SIZE(zones.info[i].free_count);
     1250                } else
     1251                        *unavail += (uint64_t) FRAMES2SIZE(zones.info[i].count);
     1252        }
     1253       
     1254        irq_spinlock_unlock(&zones.lock, true);
     1255}
     1256
     1257/** Prints list of zones.
     1258 *
     1259 */
     1260void zones_print_list(void)
    12221261{
    12231262#ifdef __32_BITS__
    1224         printf("#  base address frames       flags    free frames  busy frames\n");
    1225         printf("-- ------------ ------------ -------- ------------ ------------\n");
     1263        printf("[nr] [base addr] [frames    ] [flags ] [free frames ] [busy frames ]\n");
    12261264#endif
    12271265
    12281266#ifdef __64_BITS__
    1229         printf("#  base address          frames      flags    free frames  busy frames\n");
    1230         printf("-- -------------------- ------------ -------- ------------ ------------\n");
     1267        printf("[nr] [base address    ] [frames    ] [flags ] [free frames ] [busy frames ]\n");
    12311268#endif
    12321269       
    … …  
    12441281        size_t i;
    12451282        for (i = 0;; i++) {
    1246                 ipl_t ipl = interrupts_disable();
    1247                 spinlock_lock(&zones.lock);
     1283                irq_spinlock_lock(&zones.lock, true);
    12481284               
    12491285                if (i >= zones.count) {
    1250                         spinlock_unlock(&zones.lock);
    1251                         interrupts_restore(ipl);
     1286                        irq_spinlock_unlock(&zones.lock, true);
    12521287                        break;
    12531288                }
    … …  
    12591294                size_t busy_count = zones.info[i].busy_count;
    12601295               
    1261                 spinlock_unlock(&zones.lock);
    1262                 interrupts_restore(ipl);
     1296                irq_spinlock_unlock(&zones.lock, true);
    12631297               
    12641298                bool available = zone_flags_available(flags);
    12651299               
    1266                 printf("%-2" PRIs, i);
     1300                printf("%-4zu", i);
    12671301               
    12681302#ifdef __32_BITS__
    1269                 printf("   %10p", base);
     1303                printf("  %p", (void *) base);
    12701304#endif
    12711305               
    12721306#ifdef __64_BITS__
    1273                 printf("   %18p", base);
     1307                printf(" %p", (void *) base);
    12741308#endif
    12751309               
    1276                 printf(" %12" PRIs " %c%c%c      ", count,
     1310                printf(" %12zu %c%c%c      ", count,
    12771311                    available ? 'A' : ' ',
    12781312                    (flags & ZONE_RESERVED) ? 'R' : ' ',
    … …  
    12801314               
    12811315                if (available)
    1282                         printf("%12" PRIs " %12" PRIs,
     1316                        printf("%14zu %14zu",
    12831317                            free_count, busy_count);
    12841318               
    … …  
    12941328void zone_print_one(size_t num)
    12951329{
    1296         ipl_t ipl = interrupts_disable();
    1297         spinlock_lock(&zones.lock);
     1330        irq_spinlock_lock(&zones.lock, true);
    12981331        size_t znum = (size_t) -1;
    12991332       
    … …  
    13071340       
    13081341        if (znum == (size_t) -1) {
    1309                 spinlock_unlock(&zones.lock);
    1310                 interrupts_restore(ipl);
     1342                irq_spinlock_unlock(&zones.lock, true);
    13111343                printf("Zone not found.\n");
    13121344                return;
    … …  
    13191351        size_t busy_count = zones.info[i].busy_count;
    13201352       
    1321         spinlock_unlock(&zones.lock);
    1322         interrupts_restore(ipl);
     1353        irq_spinlock_unlock(&zones.lock, true);
    13231354       
    13241355        bool available = zone_flags_available(flags);
    13251356       
    1326         printf("Zone number:       %" PRIs "\n", znum);
    1327         printf("Zone base address: %p\n", base);
    1328         printf("Zone size:         %" PRIs " frames (%" PRIs " KiB)\n", count,
     1357        printf("Zone number:       %zu\n", znum);
     1358        printf("Zone base address: %p\n", (void *) base);
     1359        printf("Zone size:         %zu frames (%zu KiB)\n", count,
    13291360            SIZE2KB(FRAMES2SIZE(count)));
    13301361        printf("Zone flags:        %c%c%c\n",
    … …  
    13341365       
    13351366        if (available) {
    1336                 printf("Allocated space:   %" PRIs " frames (%" PRIs " KiB)\n",
     1367                printf("Allocated space:   %zu frames (%zu KiB)\n",
    13371368                    busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
    1338                 printf("Available space:   %" PRIs " frames (%" PRIs " KiB)\n",
     1369                printf("Available space:   %zu frames (%zu KiB)\n",
    13391370                    free_count, SIZE2KB(FRAMES2SIZE(free_count)));
    13401371        }
Note: See TracChangeset for help on using the changeset viewer.