Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7e752b2 r98000fb  
    4343 */
    4444
    45 #include <typedefs.h>
     45#include <arch/types.h>
    4646#include <mm/frame.h>
    4747#include <mm/as.h>
    … …  
    6666 * available.
    6767 */
    68 static mutex_t mem_avail_mtx;
    69 static condvar_t mem_avail_cv;
    70 static size_t mem_avail_req = 0;  /**< Number of frames requested. */
    71 static size_t mem_avail_gen = 0;  /**< Generation counter. */
     68mutex_t mem_avail_mtx;
     69condvar_t mem_avail_cv;
     70size_t mem_avail_req = 0;  /**< Number of frames requested. */
     71size_t mem_avail_gen = 0;  /**< Generation counter. */
    7272
    7373/********************/
    … …  
    7575/********************/
    7676
    77 NO_TRACE static inline size_t frame_index(zone_t *zone, frame_t *frame)
     77static inline size_t frame_index(zone_t *zone, frame_t *frame)
    7878{
    7979        return (size_t) (frame - zone->frames);
    8080}
    8181
    82 NO_TRACE static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
     82static 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 NO_TRACE static inline bool frame_index_valid(zone_t *zone, size_t index)
     87static inline bool frame_index_valid(zone_t *zone, size_t index)
    8888{
    8989        return (index < zone->count);
    9090}
    9191
    92 NO_TRACE static inline size_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);
    … …  
    100100 *
    101101 */
    102 NO_TRACE static void frame_initialize(frame_t *frame)
     102static void frame_initialize(frame_t *frame)
    103103{
    104104        frame->refcount = 1;
    … …  
    121121 *
    122122 */
    123 NO_TRACE static size_t zones_insert_zone(pfn_t base, size_t count,
    124     zone_flags_t flags)
     123static size_t zones_insert_zone(pfn_t base, size_t count)
    125124{
    126125        if (zones.count + 1 == ZONES_MAX) {
    … …  
    132131        for (i = 0; i < zones.count; i++) {
    133132                /* Check for overlap */
    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                        
     133                if (overlaps(base, count,
     134                    zones.info[i].base, zones.info[i].count)) {
     135                        printf("Zones overlap!\n");
    154136                        return (size_t) -1;
    155137                }
    … …  
    162144        for (j = zones.count; j > i; j--) {
    163145                zones.info[j] = zones.info[j - 1];
    164                 if (zones.info[j].buddy_system != NULL)
    165                         zones.info[j].buddy_system->data =
    166                             (void *) &zones.info[j];
     146                zones.info[j].buddy_system->data =
     147                    (void *) &zones.info[j - 1];
    167148        }
    168149       
    … …  
    181162 */
    182163#ifdef CONFIG_DEBUG
    183 NO_TRACE static size_t total_frames_free(void)
     164static size_t total_frames_free(void)
    184165{
    185166        size_t total = 0;
    … …  
    190171        return total;
    191172}
    192 #endif /* CONFIG_DEBUG */
     173#endif
    193174
    194175/** Find a zone with a given frames.
    … …  
    204185 *
    205186 */
    206 NO_TRACE size_t find_zone(pfn_t frame, size_t count, size_t hint)
     187size_t find_zone(pfn_t frame, size_t count, size_t hint)
    207188{
    208189        if (hint >= zones.count)
    … …  
    218199                if (i >= zones.count)
    219200                        i = 0;
    220                
    221201        } while (i != hint);
    222202       
    … …  
    225205
    226206/** @return True if zone can allocate specified order */
    227 NO_TRACE static bool zone_can_alloc(zone_t *zone, uint8_t order)
     207static bool zone_can_alloc(zone_t *zone, uint8_t order)
    228208{
    229209        return (zone_flags_available(zone->flags)
    … …  
    241221 *
    242222 */
    243 NO_TRACE static size_t find_free_zone(uint8_t order, zone_flags_t flags,
    244     size_t hint)
     223static size_t find_free_zone(uint8_t order, zone_flags_t flags, size_t hint)
    245224{
    246225        if (hint >= zones.count)
    … …  
    263242                if (i >= zones.count)
    264243                        i = 0;
    265                
    266244        } while (i != hint);
    267245       
    … …  
    282260 *
    283261 */
    284 NO_TRACE static link_t *zone_buddy_find_block(buddy_system_t *buddy,
    285     link_t *child, uint8_t order)
     262static link_t *zone_buddy_find_block(buddy_system_t *buddy, link_t *child,
     263    uint8_t order)
    286264{
    287265        frame_t *frame = list_get_instance(child, frame_t, buddy_link);
    … …  
    305283 *
    306284 */
    307 NO_TRACE static link_t *zone_buddy_find_buddy(buddy_system_t *buddy,
    308     link_t *block)
     285static link_t *zone_buddy_find_buddy(buddy_system_t *buddy, link_t *block)
    309286{
    310287        frame_t *frame = list_get_instance(block, frame_t, buddy_link);
    … …  
    319296                index = (frame_index(zone, frame)) +
    320297                    (1 << frame->buddy_order);
    321         } else {  /* is_right */
     298        } else {        /* is_right */
    322299                index = (frame_index(zone, frame)) -
    323300                    (1 << frame->buddy_order);
    … …  
    342319 *
    343320 */
    344 NO_TRACE static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
     321static link_t *zone_buddy_bisect(buddy_system_t *buddy, link_t *block)
    345322{
    346323        frame_t *frame_l = list_get_instance(block, frame_t, buddy_link);
    … …  
    360337 *
    361338 */
    362 NO_TRACE static link_t *zone_buddy_coalesce(buddy_system_t *buddy,
    363     link_t *block_1, link_t *block_2)
     339static link_t *zone_buddy_coalesce(buddy_system_t *buddy, link_t *block_1,
     340    link_t *block_2)
    364341{
    365342        frame_t *frame1 = list_get_instance(block_1, frame_t, buddy_link);
    … …  
    376353 *
    377354 */
    378 NO_TRACE static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
     355static void zone_buddy_set_order(buddy_system_t *buddy, link_t *block,
    379356    uint8_t order)
    380357{
    … …  
    390367 *
    391368 */
    392 NO_TRACE static uint8_t zone_buddy_get_order(buddy_system_t *buddy,
    393     link_t *block)
     369static uint8_t zone_buddy_get_order(buddy_system_t *buddy, link_t *block)
    394370{
    395371        return list_get_instance(block, frame_t, buddy_link)->buddy_order;
    … …  
    402378 *
    403379 */
    404 NO_TRACE static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t *block)
     380static void zone_buddy_mark_busy(buddy_system_t *buddy, link_t * block)
    405381{
    406382        list_get_instance(block, frame_t, buddy_link)->refcount = 1;
    … …  
    411387 * @param buddy Buddy system.
    412388 * @param block Buddy system block.
    413  *
    414  */
    415 NO_TRACE static void zone_buddy_mark_available(buddy_system_t *buddy,
    416     link_t *block)
     389 */
     390static void zone_buddy_mark_available(buddy_system_t *buddy, link_t *block)
    417391{
    418392        list_get_instance(block, frame_t, buddy_link)->refcount = 0;
    … …  
    445419 *
    446420 */
    447 NO_TRACE static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
     421static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
    448422{
    449423        ASSERT(zone_flags_available(zone->flags));
    … …  
    473447 *
    474448 */
    475 NO_TRACE static void zone_frame_free(zone_t *zone, size_t frame_idx)
     449static void zone_frame_free(zone_t *zone, size_t frame_idx)
    476450{
    477451        ASSERT(zone_flags_available(zone->flags));
    … …  
    494468
    495469/** Return frame from zone. */
    496 NO_TRACE static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
     470static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
    497471{
    498472        ASSERT(frame_idx < zone->count);
    … …  
    501475
    502476/** Mark frame in zone unavailable to allocation. */
    503 NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
     477static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
    504478{
    505479        ASSERT(zone_flags_available(zone->flags));
    … …  
    530504 *
    531505 */
    532 NO_TRACE static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1,
    533     buddy_system_t *buddy)
     506static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1, buddy_system_t *buddy)
    534507{
    535508        ASSERT(zone_flags_available(zones.info[z1].flags));
    … …  
    627600 *
    628601 */
    629 NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
     602static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
    630603{
    631604        ASSERT(zone_flags_available(zones.info[znum].flags));
    … …  
    662635 *
    663636 */
    664 NO_TRACE static void zone_reduce_region(size_t znum, pfn_t frame_idx,
    665     size_t count)
     637static void zone_reduce_region(size_t znum, pfn_t frame_idx, size_t count)
    666638{
    667639        ASSERT(zone_flags_available(zones.info[znum].flags));
    … …  
    701673bool zone_merge(size_t z1, size_t z2)
    702674{
    703         irq_spinlock_lock(&zones.lock, true);
     675        ipl_t ipl = interrupts_disable();
     676        spinlock_lock(&zones.lock);
    704677       
    705678        bool ret = true;
    … …  
    764737        for (i = z2 + 1; i < zones.count; i++) {
    765738                zones.info[i - 1] = zones.info[i];
    766                 if (zones.info[i - 1].buddy_system != NULL)
    767                         zones.info[i - 1].buddy_system->data =
    768                             (void *) &zones.info[i - 1];
     739                zones.info[i - 1].buddy_system->data =
     740                    (void *) &zones.info[i - 1];
    769741        }
    770742       
    … …  
    772744       
    773745errout:
    774         irq_spinlock_unlock(&zones.lock, true);
     746        spinlock_unlock(&zones.lock);
     747        interrupts_restore(ipl);
    775748       
    776749        return ret;
    … …  
    804777 *
    805778 */
    806 NO_TRACE static void zone_construct(zone_t *zone, buddy_system_t *buddy,
    807     pfn_t start, size_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)
    808780{
    809781        zone->base = start;
    … …  
    848820 *
    849821 */
    850 size_t zone_conf_size(size_t count)
     822uintptr_t zone_conf_size(size_t count)
    851823{
    852824        return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
    … …  
    869841 *
    870842 */
    871 size_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);
     843size_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);
    875847       
    876848        if (zone_flags_available(flags)) {  /* Create available zone */
    … …  
    879851                 * the assert
    880852                 */
    881                 ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
     853                ASSERT(confframe != NULL);
    882854               
    883855                /* If confframe is supposed to be inside our zone, then make sure
    … …  
    915887                }
    916888               
    917                 size_t znum = zones_insert_zone(start, count, flags);
     889                size_t znum = zones_insert_zone(start, count);
    918890                if (znum == (size_t) -1) {
    919                         irq_spinlock_unlock(&zones.lock, true);
     891                        spinlock_unlock(&zones.lock);
     892                        interrupts_restore(ipl);
    920893                        return (size_t) -1;
    921894                }
    … …  
    932905                }
    933906               
    934                 irq_spinlock_unlock(&zones.lock, true);
     907                spinlock_unlock(&zones.lock);
     908                interrupts_restore(ipl);
    935909               
    936910                return znum;
    … …  
    938912       
    939913        /* Non-available zone */
    940         size_t znum = zones_insert_zone(start, count, flags);
     914        size_t znum = zones_insert_zone(start, count);
    941915        if (znum == (size_t) -1) {
    942                 irq_spinlock_unlock(&zones.lock, true);
     916                spinlock_unlock(&zones.lock);
     917                interrupts_restore(ipl);
    943918                return (size_t) -1;
    944919        }
    945920        zone_construct(&zones.info[znum], NULL, start, count, flags);
    946921       
    947         irq_spinlock_unlock(&zones.lock, true);
     922        spinlock_unlock(&zones.lock);
     923        interrupts_restore(ipl);
    948924       
    949925        return znum;
    … …  
    957933void frame_set_parent(pfn_t pfn, void *data, size_t hint)
    958934{
    959         irq_spinlock_lock(&zones.lock, true);
     935        ipl_t ipl = interrupts_disable();
     936        spinlock_lock(&zones.lock);
    960937       
    961938        size_t znum = find_zone(pfn, 1, hint);
    … …  
    966943            pfn - zones.info[znum].base)->parent = data;
    967944       
    968         irq_spinlock_unlock(&zones.lock, true);
     945        spinlock_unlock(&zones.lock);
     946        interrupts_restore(ipl);
    969947}
    970948
    971949void *frame_get_parent(pfn_t pfn, size_t hint)
    972950{
    973         irq_spinlock_lock(&zones.lock, true);
     951        ipl_t ipl = interrupts_disable();
     952        spinlock_lock(&zones.lock);
    974953       
    975954        size_t znum = find_zone(pfn, 1, hint);
    … …  
    980959            pfn - zones.info[znum].base)->parent;
    981960       
    982         irq_spinlock_unlock(&zones.lock, true);
     961        spinlock_unlock(&zones.lock);
     962        interrupts_restore(ipl);
    983963       
    984964        return res;
    … …  
    997977{
    998978        size_t size = ((size_t) 1) << order;
     979        ipl_t ipl;
    999980        size_t hint = pzone ? (*pzone) : 0;
    1000981       
    1001982loop:
    1002         irq_spinlock_lock(&zones.lock, true);
     983        ipl = interrupts_disable();
     984        spinlock_lock(&zones.lock);
    1003985       
    1004986        /*
    … …  
    1011993           if it does not help, reclaim all */
    1012994        if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
    1013                 irq_spinlock_unlock(&zones.lock, true);
     995                spinlock_unlock(&zones.lock);
     996                interrupts_restore(ipl);
     997               
    1014998                size_t freed = slab_reclaim(0);
    1015                 irq_spinlock_lock(&zones.lock, true);
     999               
     1000                ipl = interrupts_disable();
     1001                spinlock_lock(&zones.lock);
    10161002               
    10171003                if (freed > 0)
    … …  
    10201006               
    10211007                if (znum == (size_t) -1) {
    1022                         irq_spinlock_unlock(&zones.lock, true);
     1008                        spinlock_unlock(&zones.lock);
     1009                        interrupts_restore(ipl);
     1010                       
    10231011                        freed = slab_reclaim(SLAB_RECLAIM_ALL);
    1024                         irq_spinlock_lock(&zones.lock, true);
     1012                       
     1013                        ipl = interrupts_disable();
     1014                        spinlock_lock(&zones.lock);
    10251015                       
    10261016                        if (freed > 0)
    … …  
    10321022        if (znum == (size_t) -1) {
    10331023                if (flags & FRAME_ATOMIC) {
    1034                         irq_spinlock_unlock(&zones.lock, true);
     1024                        spinlock_unlock(&zones.lock);
     1025                        interrupts_restore(ipl);
    10351026                        return NULL;
    10361027                }
    … …  
    10401031#endif
    10411032               
    1042                 irq_spinlock_unlock(&zones.lock, true);
    1043                
    1044                 if (!THREAD)
    1045                         panic("Cannot wait for memory to become available.");
     1033                spinlock_unlock(&zones.lock);
     1034                interrupts_restore(ipl);
    10461035               
    10471036                /*
    … …  
    10501039               
    10511040#ifdef CONFIG_DEBUG
    1052                 printf("Thread %" PRIu64 " waiting for %zu frames, "
    1053                     "%zu available.\n", THREAD->tid, size, avail);
     1041                printf("Thread %" PRIu64 " waiting for %" PRIs " frames, "
     1042                    "%" PRIs " available.\n", THREAD->tid, size, avail);
    10541043#endif
    10551044               
    … …  
    10771066            + zones.info[znum].base;
    10781067       
    1079         irq_spinlock_unlock(&zones.lock, true);
     1068        spinlock_unlock(&zones.lock);
     1069        interrupts_restore(ipl);
    10801070       
    10811071        if (pzone)
    … …  
    10991089void frame_free(uintptr_t frame)
    11001090{
    1101         irq_spinlock_lock(&zones.lock, true);
     1091        ipl_t ipl = interrupts_disable();
     1092        spinlock_lock(&zones.lock);
    11021093       
    11031094        /*
    … …  
    11051096         */
    11061097        pfn_t pfn = ADDR2PFN(frame);
    1107         size_t znum = find_zone(pfn, 1, 0);
     1098        size_t znum = find_zone(pfn, 1, NULL);
    11081099       
    11091100        ASSERT(znum != (size_t) -1);
    … …  
    11111102        zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
    11121103       
    1113         irq_spinlock_unlock(&zones.lock, true);
     1104        spinlock_unlock(&zones.lock);
     1105        interrupts_restore(ipl);
    11141106       
    11151107        /*
    … …  
    11351127 *
    11361128 */
    1137 NO_TRACE void frame_reference_add(pfn_t pfn)
    1138 {
    1139         irq_spinlock_lock(&zones.lock, true);
     1129void frame_reference_add(pfn_t pfn)
     1130{
     1131        ipl_t ipl = interrupts_disable();
     1132        spinlock_lock(&zones.lock);
    11401133       
    11411134        /*
    11421135         * First, find host frame zone for addr.
    11431136         */
    1144         size_t znum = find_zone(pfn, 1, 0);
     1137        size_t znum = find_zone(pfn, 1, NULL);
    11451138       
    11461139        ASSERT(znum != (size_t) -1);
    … …  
    11481141        zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
    11491142       
    1150         irq_spinlock_unlock(&zones.lock, true);
    1151 }
    1152 
    1153 /** Mark given range unavailable in frame zones.
    1154  *
    1155  */
    1156 NO_TRACE void frame_mark_unavailable(pfn_t start, size_t count)
    1157 {
    1158         irq_spinlock_lock(&zones.lock, true);
     1143        spinlock_unlock(&zones.lock);
     1144        interrupts_restore(ipl);
     1145}
     1146
     1147/** Mark given range unavailable in frame zones. */
     1148void frame_mark_unavailable(pfn_t start, size_t count)
     1149{
     1150        ipl_t ipl = interrupts_disable();
     1151        spinlock_lock(&zones.lock);
    11591152       
    11601153        size_t i;
    … …  
    11681161        }
    11691162       
    1170         irq_spinlock_unlock(&zones.lock, true);
    1171 }
    1172 
    1173 /** Initialize physical memory management.
    1174  *
    1175  */
     1163        spinlock_unlock(&zones.lock);
     1164        interrupts_restore(ipl);
     1165}
     1166
     1167/** Initialize physical memory management. */
    11761168void frame_init(void)
    11771169{
    11781170        if (config.cpu_active == 1) {
    11791171                zones.count = 0;
    1180                 irq_spinlock_initialize(&zones.lock, "frame.zones.lock");
     1172                spinlock_initialize(&zones.lock, "zones.lock");
    11811173                mutex_initialize(&mem_avail_mtx, MUTEX_ACTIVE);
    11821174                condvar_initialize(&mem_avail_cv);
    … …  
    12091201}
    12101202
    1211 /** Return total size of all zones.
    1212  *
    1213  */
    1214 uint64_t zones_total_size(void)
    1215 {
    1216         irq_spinlock_lock(&zones.lock, true);
     1203/** Return total size of all zones. */
     1204uint64_t zone_total_size(void)
     1205{
     1206        ipl_t ipl = interrupts_disable();
     1207        spinlock_lock(&zones.lock);
    12171208       
    12181209        uint64_t total = 0;
    … …  
    12211212                total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
    12221213       
    1223         irq_spinlock_unlock(&zones.lock, true);
     1214        spinlock_unlock(&zones.lock);
     1215        interrupts_restore(ipl);
    12241216       
    12251217        return total;
    12261218}
    12271219
    1228 void 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  */
    1260 void zones_print_list(void)
     1220/** Prints list of zones. */
     1221void zone_print_list(void)
    12611222{
    12621223#ifdef __32_BITS__
    1263         printf("[nr] [base addr] [frames    ] [flags ] [free frames ] [busy frames ]\n");
     1224        printf("#  base address frames       flags    free frames  busy frames\n");
     1225        printf("-- ------------ ------------ -------- ------------ ------------\n");
    12641226#endif
    12651227
    12661228#ifdef __64_BITS__
    1267         printf("[nr] [base address    ] [frames    ] [flags ] [free frames ] [busy frames ]\n");
     1229        printf("#  base address          frames      flags    free frames  busy frames\n");
     1230        printf("-- -------------------- ------------ -------- ------------ ------------\n");
    12681231#endif
    12691232       
    … …  
    12811244        size_t i;
    12821245        for (i = 0;; i++) {
    1283                 irq_spinlock_lock(&zones.lock, true);
     1246                ipl_t ipl = interrupts_disable();
     1247                spinlock_lock(&zones.lock);
    12841248               
    12851249                if (i >= zones.count) {
    1286                         irq_spinlock_unlock(&zones.lock, true);
     1250                        spinlock_unlock(&zones.lock);
     1251                        interrupts_restore(ipl);
    12871252                        break;
    12881253                }
    … …  
    12941259                size_t busy_count = zones.info[i].busy_count;
    12951260               
    1296                 irq_spinlock_unlock(&zones.lock, true);
     1261                spinlock_unlock(&zones.lock);
     1262                interrupts_restore(ipl);
    12971263               
    12981264                bool available = zone_flags_available(flags);
    12991265               
    1300                 printf("%-4zu", i);
     1266                printf("%-2" PRIs, i);
    13011267               
    13021268#ifdef __32_BITS__
    1303                 printf("  %p", (void *) base);
     1269                printf("   %10p", base);
    13041270#endif
    13051271               
    13061272#ifdef __64_BITS__
    1307                 printf(" %p", (void *) base);
     1273                printf("   %18p", base);
    13081274#endif
    13091275               
    1310                 printf(" %12zu %c%c%c      ", count,
     1276                printf(" %12" PRIs " %c%c%c      ", count,
    13111277                    available ? 'A' : ' ',
    13121278                    (flags & ZONE_RESERVED) ? 'R' : ' ',
    … …  
    13141280               
    13151281                if (available)
    1316                         printf("%14zu %14zu",
     1282                        printf("%12" PRIs " %12" PRIs,
    13171283                            free_count, busy_count);
    13181284               
    … …  
    13281294void zone_print_one(size_t num)
    13291295{
    1330         irq_spinlock_lock(&zones.lock, true);
     1296        ipl_t ipl = interrupts_disable();
     1297        spinlock_lock(&zones.lock);
    13311298        size_t znum = (size_t) -1;
    13321299       
    … …  
    13401307       
    13411308        if (znum == (size_t) -1) {
    1342                 irq_spinlock_unlock(&zones.lock, true);
     1309                spinlock_unlock(&zones.lock);
     1310                interrupts_restore(ipl);
    13431311                printf("Zone not found.\n");
    13441312                return;
    … …  
    13511319        size_t busy_count = zones.info[i].busy_count;
    13521320       
    1353         irq_spinlock_unlock(&zones.lock, true);
     1321        spinlock_unlock(&zones.lock);
     1322        interrupts_restore(ipl);
    13541323       
    13551324        bool available = zone_flags_available(flags);
    13561325       
    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,
     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,
    13601329            SIZE2KB(FRAMES2SIZE(count)));
    13611330        printf("Zone flags:        %c%c%c\n",
    … …  
    13651334       
    13661335        if (available) {
    1367                 printf("Allocated space:   %zu frames (%zu KiB)\n",
     1336                printf("Allocated space:   %" PRIs " frames (%" PRIs " KiB)\n",
    13681337                    busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
    1369                 printf("Available space:   %zu frames (%zu KiB)\n",
     1338                printf("Available space:   %" PRIs " frames (%" PRIs " KiB)\n",
    13701339                    free_count, SIZE2KB(FRAMES2SIZE(free_count)));
    13711340        }
Note: See TracChangeset for help on using the changeset viewer.