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

Timestamp:

2018-03-02T20:10:49Z (7 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f1380b7

Parents:

3061bc1

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)

Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

File:

• kernel/generic/src/mm/frame.c (modified) (72 diffs)

kernel/generic/src/mm/frame.c

@@ -108 +108 @@
                 return (size_t) -1;
         }
-        
+
         size_t i;
         for (i = 0; i < zones.count; i++) {
@@ -114 +114 @@
                 if (overlaps(zones.info[i].base, zones.info[i].count,
                     base, count)) {
-                        
+
                         /*
                          * If the overlaping zones are of the same type
@@ -121 +121 @@
                          *
                          */
-                        
+
                         if ((zones.info[i].flags != flags) ||
                             (!iswithin(zones.info[i].base, zones.info[i].count,
@@ -132 +132 @@
                                     (void *) PFN2ADDR(zones.info[i].count));
                         }
-                        
+
                         return (size_t) -1;
                 }
@@ -138 +138 @@
                         break;
         }
-        
+
         /* Move other zones up */
         for (size_t j = zones.count; j > i; j--)
                 zones.info[j] = zones.info[j - 1];
-        
+
         zones.count++;
-        
+
         return i;
 }
@@ -163 +163 @@
         for (i = 0; i < zones.count; i++)
                 total += zones.info[i].free_count;
-        
+
         return total;
 }
@@ -195 +195 @@
         if (hint >= zones.count)
                 hint = 0;
-        
+
         size_t i = hint;
         do {
@@ -201 +201 @@
                     && (zones.info[i].base + zones.info[i].count >= frame + count))
                         return i;
-                
+
                 i++;
                 if (i >= zones.count)
                         i = 0;
-                
+
         } while (i != hint);
-        
+
         return (size_t) -1;
 }
@@ -219 +219 @@
          * the bitmap if the last argument is NULL.
          */
-        
+
         return ((zone->flags & ZONE_AVAILABLE) &&
             bitmap_allocate_range(&zone->bitmap, count, zone->base,
@@ -245 +245 @@
         for (size_t pos = 0; pos < zones.count; pos++) {
                 size_t i = (pos + hint) % zones.count;
-                
+
                 /* Check whether the zone meets the search criteria. */
                 if (!ZONE_FLAGS_MATCH(zones.info[i].flags, flags))
                         continue;
-                
+
                 /* Check if the zone can satisfy the allocation request. */
                 if (zone_can_alloc(&zones.info[i], count, constraint))
                         return i;
         }
-        
+
         return (size_t) -1;
 }
@@ -291 +291 @@
         for (size_t pos = 0; pos < zones.count; pos++) {
                 size_t i = (pos + hint) % zones.count;
-                
+
                 /* Skip zones containing only high-priority memory. */
                 if (is_high_priority(zones.info[i].base, zones.info[i].count))
                         continue;
-                
+
                 /* Check whether the zone meets the search criteria. */
                 if (!ZONE_FLAGS_MATCH(zones.info[i].flags, flags))
                         continue;
-                
+
                 /* Check if the zone can satisfy the allocation request. */
                 if (zone_can_alloc(&zones.info[i], count, constraint))
                         return i;
         }
-        
+
         return (size_t) -1;
 }
@@ -328 +328 @@
         if (hint >= zones.count)
                 hint = 0;
-        
+
         /*
          * Prefer zones with low-priority memory over
          * zones with high-priority memory.
          */
-        
+
         size_t znum = find_free_zone_lowprio(count, flags, constraint, hint);
         if (znum != (size_t) -1)
                 return znum;
-        
+
         /* Take all zones into account */
         return find_free_zone_all(count, flags, constraint, hint);
@@ -350 +350 @@
 {
         assert(index < zone->count);
-        
+
         return &zone->frames[index];
 }
@@ -371 +371 @@
 {
         assert(zone->flags & ZONE_AVAILABLE);
-        
+
         /* Allocate frames from zone */
         size_t index = (size_t) -1;
         int avail = bitmap_allocate_range(&zone->bitmap, count, zone->base,
             FRAME_LOWPRIO, constraint, &index);
-        
+
         assert(avail);
         assert(index != (size_t) -1);
-        
+
         /* Update frame reference count */
         for (size_t i = 0; i < count; i++) {
                 frame_t *frame = zone_get_frame(zone, index + i);
-                
+
                 assert(frame->refcount == 0);
                 frame->refcount = 1;
         }
-        
+
         /* Update zone information. */
         zone->free_count -= count;
         zone->busy_count += count;
-        
+
         return index;
 }
@@ -408 +408 @@
 {
         assert(zone->flags & ZONE_AVAILABLE);
-        
+
         frame_t *frame = zone_get_frame(zone, index);
-        
+
         assert(frame->refcount > 0);
-        
+
         if (!--frame->refcount) {
                 bitmap_set(&zone->bitmap, index, 0);
-                
+
                 /* Update zone information. */
                 zone->free_count++;
                 zone->busy_count--;
-                
+
                 return 1;
         }
-        
+
         return 0;
 }
@@ -430 +430 @@
 {
         assert(zone->flags & ZONE_AVAILABLE);
-        
+
         frame_t *frame = zone_get_frame(zone, index);
         if (frame->refcount > 0)
                 return;
-        
+
         frame->refcount = 1;
         bitmap_set_range(&zone->bitmap, index, 1);
-        
+
         zone->free_count--;
         reserve_force_alloc(1);
@@ -462 +462 @@
         assert(!overlaps(zones.info[z1].base, zones.info[z1].count,
             zones.info[z2].base, zones.info[z2].count));
-        
+
         /* Difference between zone bases */
         pfn_t base_diff = zones.info[z2].base - zones.info[z1].base;
-        
+
         zones.info[z1].count = base_diff + zones.info[z2].count;
         zones.info[z1].free_count += zones.info[z2].free_count;
         zones.info[z1].busy_count += zones.info[z2].busy_count;
-        
+
         bitmap_initialize(&zones.info[z1].bitmap, zones.info[z1].count,
             confdata + (sizeof(frame_t) * zones.info[z1].count));
         bitmap_clear_range(&zones.info[z1].bitmap, 0, zones.info[z1].count);
-        
+
         zones.info[z1].frames = (frame_t *) confdata;
-        
+
         /*
          * Copy frames and bits from both zones to preserve parents, etc.
          */
-        
+
         for (size_t i = 0; i < old_z1->count; i++) {
                 bitmap_set(&zones.info[z1].bitmap, i,
@@ -485 +485 @@
                 zones.info[z1].frames[i] = old_z1->frames[i];
         }
-        
+
         for (size_t i = 0; i < zones.info[z2].count; i++) {
                 bitmap_set(&zones.info[z1].bitmap, base_diff + i,
@@ -510 +510 @@
 {
         assert(zones.info[znum].flags & ZONE_AVAILABLE);
-        
+
         size_t cframes = SIZE2FRAMES(zone_conf_size(count));
-        
+
         if ((pfn < zones.info[znum].base) ||
             (pfn >= zones.info[znum].base + zones.info[znum].count))
                 return;
-        
+
         for (size_t i = 0; i < cframes; i++)
                 (void) zone_frame_free(&zones.info[znum],
@@ -536 +536 @@
 {
         irq_spinlock_lock(&zones.lock, true);
-        
+
         bool ret = true;
-        
+
         /*
          * We can join only 2 zones with none existing inbetween,
@@ -549 +549 @@
                 goto errout;
         }
-        
+
         pfn_t cframes = SIZE2FRAMES(zone_conf_size(
             zones.info[z2].base - zones.info[z1].base
             + zones.info[z2].count));
-        
+
         /* Allocate merged zone data inside one of the zones */
         pfn_t pfn;
@@ -566 +566 @@
                 goto errout;
         }
-        
+
         /* Preserve original data from z1 */
         zone_t old_z1 = zones.info[z1];
-        
+
         /* Do zone merging */
         zone_merge_internal(z1, z2, &old_z1, (void *) PA2KA(PFN2ADDR(pfn)));
-        
+
         /* Subtract zone information from busy frames */
         zones.info[z1].busy_count -= cframes;
-        
+
         /* Free old zone information */
         return_config_frames(z1,
@@ -582 +582 @@
             ADDR2PFN(KA2PA((uintptr_t) zones.info[z2].frames)),
             zones.info[z2].count);
-        
+
         /* Move zones down */
         for (size_t i = z2 + 1; i < zones.count; i++)
                 zones.info[i - 1] = zones.info[i];
-        
+
         zones.count--;
-        
+
 errout:
         irq_spinlock_unlock(&zones.lock, true);
-        
+
         return ret;
 }
@@ -605 +605 @@
 {
         size_t i = 1;
-        
+
         while (i < zones.count) {
                 if (!zone_merge(i - 1, i))
@@ -631 +631 @@
         zone->free_count = count;
         zone->busy_count = 0;
-        
+
         if (flags & ZONE_AVAILABLE) {
                 /*
@@ -637 +637 @@
                  * frame_t structures in the configuration space).
                  */
-                
+
                 bitmap_initialize(&zone->bitmap, count, confdata +
                     (sizeof(frame_t) * count));
                 bitmap_clear_range(&zone->bitmap, 0, count);
-                
+
                 /*
                  * Initialize the array of frame_t structures.
                  */
-                
+
                 zone->frames = (frame_t *) confdata;
-                
+
                 for (size_t i = 0; i < count; i++)
                         frame_initialize(&zone->frames[i]);
@@ -672 +672 @@
 {
         size_t frames = SIZE2FRAMES(zone_conf_size(count));
-        
+
         return ADDR2PFN((uintptr_t)
             frame_alloc(frames, FRAME_LOWMEM | FRAME_ATOMIC, 0));
@@ -697 +697 @@
 {
         irq_spinlock_lock(&zones.lock, true);
-        
+
         if (flags & ZONE_AVAILABLE) {  /* Create available zone */
                 /*
@@ -705 +705 @@
                  */
                 assert(confframe != ADDR2PFN((uintptr_t ) NULL));
-                
+
                 /* Update the known end of physical memory. */
                 config.physmem_end = max(config.physmem_end, PFN2ADDR(start + count));
-                
+
                 /*
                  * If confframe is supposed to be inside our zone, then make sure
@@ -714 +714 @@
                  */
                 size_t confcount = SIZE2FRAMES(zone_conf_size(count));
-                
+
                 if ((confframe >= start) && (confframe < start + count)) {
                         for (; confframe < start + count; confframe++) {
@@ -721 +721 @@
                                     KA2PA(config.base), config.kernel_size))
                                         continue;
-                                
+
                                 if (overlaps(addr, PFN2ADDR(confcount),
                                     KA2PA(config.stack_base), config.stack_size))
                                         continue;
-                                
+
                                 bool overlap = false;
                                 for (size_t i = 0; i < init.cnt; i++) {
@@ -735 +735 @@
                                         }
                                 }
-                                
+
                                 if (overlap)
                                         continue;
-                                
+
                                 break;
                         }
-                        
+
                         if (confframe >= start + count)
                                 panic("Cannot find configuration data for zone.");
                 }
-                
+
                 size_t znum = zones_insert_zone(start, count, flags);
                 if (znum == (size_t) -1) {
@@ -751 +751 @@
                         return (size_t) -1;
                 }
-                
+
                 void *confdata = (void *) PA2KA(PFN2ADDR(confframe));
                 zone_construct(&zones.info[znum], start, count, flags, confdata);
-                
+
                 /* If confdata in zone, mark as unavailable */
                 if ((confframe >= start) && (confframe < start + count)) {
@@ -761 +761 @@
                                     i - zones.info[znum].base);
                 }
-                
+
                 irq_spinlock_unlock(&zones.lock, true);
-                
+
                 return znum;
         }
-        
+
         /* Non-available zone */
         size_t znum = zones_insert_zone(start, count, flags);
@@ -773 +773 @@
                 return (size_t) -1;
         }
-        
+
         zone_construct(&zones.info[znum], start, count, flags, NULL);
-        
+
         irq_spinlock_unlock(&zones.lock, true);
-        
+
         return znum;
 }
@@ -789 +789 @@
 {
         irq_spinlock_lock(&zones.lock, true);
-        
+
         size_t znum = find_zone(pfn, 1, hint);
-        
+
         assert(znum != (size_t) -1);
-        
+
         zone_get_frame(&zones.info[znum],
             pfn - zones.info[znum].base)->parent = data;
-        
+
         irq_spinlock_unlock(&zones.lock, true);
 }
@@ -803 +803 @@
 {
         irq_spinlock_lock(&zones.lock, true);
-        
+
         size_t znum = find_zone(pfn, 1, hint);
-        
+
         assert(znum != (size_t) -1);
-        
+
         void *res = zone_get_frame(&zones.info[znum],
             pfn - zones.info[znum].base)->parent;
-        
+
         irq_spinlock_unlock(&zones.lock, true);
-        
+
         return res;
 }
@@ -831 +831 @@
 {
         assert(count > 0);
-        
+
         size_t hint = pzone ? (*pzone) : 0;
         pfn_t frame_constraint = ADDR2PFN(constraint);
-        
+
         /*
          * If not told otherwise, we must first reserve the memory.
@@ -840 +840 @@
         if (!(flags & FRAME_NO_RESERVE))
                 reserve_force_alloc(count);
-        
+
 loop:
         irq_spinlock_lock(&zones.lock, true);
-        
+
         /*
          * First, find suitable frame zone.
@@ -849 +849 @@
         size_t znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags),
             frame_constraint, hint);
-        
+
         /*
          * If no memory, reclaim some slab memory,
@@ -858 +858 @@
                 size_t freed = slab_reclaim(0);
                 irq_spinlock_lock(&zones.lock, true);
-                
+
                 if (freed > 0)
                         znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags),
                             frame_constraint, hint);
-                
+
                 if (znum == (size_t) -1) {
                         irq_spinlock_unlock(&zones.lock, true);
                         freed = slab_reclaim(SLAB_RECLAIM_ALL);
                         irq_spinlock_lock(&zones.lock, true);
-                        
+
                         if (freed > 0)
                                 znum = find_free_zone(count, FRAME_TO_ZONE_FLAGS(flags),
@@ -873 +873 @@
                 }
         }
-        
+
         if (znum == (size_t) -1) {
                 if (flags & FRAME_ATOMIC) {
                         irq_spinlock_unlock(&zones.lock, true);
-                        
+
                         if (!(flags & FRAME_NO_RESERVE))
                                 reserve_free(count);
-                        
+
                         return 0;
                 }
-                
+
                 size_t avail = frame_total_free_get_internal();
-                
+
                 irq_spinlock_unlock(&zones.lock, true);
-                
+
                 if (!THREAD)
                         panic("Cannot wait for %zu frames to become available "
                             "(%zu available).", count, avail);
-                
+
                 /*
                  * Sleep until some frames are available again.
                  */
-                
+
 #ifdef CONFIG_DEBUG
                 log(LF_OTHER, LVL_DEBUG,
@@ -901 +901 @@
                     "%zu available.", THREAD->tid, count, avail);
 #endif
-                
+
                 /*
                  * Since the mem_avail_mtx is an active mutex, we need to
@@ -908 +908 @@
                 ipl_t ipl = interrupts_disable();
                 mutex_lock(&mem_avail_mtx);
-                
+
                 if (mem_avail_req > 0)
                         mem_avail_req = min(mem_avail_req, count);
                 else
                         mem_avail_req = count;
-                
+
                 size_t gen = mem_avail_gen;
-                
+
                 while (gen == mem_avail_gen)
                         condvar_wait(&mem_avail_cv, &mem_avail_mtx);
-                
+
                 mutex_unlock(&mem_avail_mtx);
                 interrupts_restore(ipl);
-                
+
 #ifdef CONFIG_DEBUG
                 log(LF_OTHER, LVL_DEBUG, "Thread %" PRIu64 " woken up.",
                     THREAD->tid);
 #endif
-                
+
                 goto loop;
         }
-        
+
         pfn_t pfn = zone_frame_alloc(&zones.info[znum], count,
             frame_constraint) + zones.info[znum].base;
-        
+
         irq_spinlock_unlock(&zones.lock, true);
-        
+
         if (pzone)
                 *pzone = znum;
-        
+
         return PFN2ADDR(pfn);
 }
@@ -960 +960 @@
 {
         size_t freed = 0;
-        
+
         irq_spinlock_lock(&zones.lock, true);
-        
+
         for (size_t i = 0; i < count; i++) {
                 /*
@@ -969 +969 @@
                 pfn_t pfn = ADDR2PFN(start) + i;
                 size_t znum = find_zone(pfn, 1, 0);
-                
+
                 assert(znum != (size_t) -1);
-                
+
                 freed += zone_frame_free(&zones.info[znum],
                     pfn - zones.info[znum].base);
         }
-        
+
         irq_spinlock_unlock(&zones.lock, true);
-        
+
         /*
          * Signal that some memory has been freed.
@@ -984 +984 @@
          * with TLB shootdown.
          */
-        
+
         ipl_t ipl = interrupts_disable();
         mutex_lock(&mem_avail_mtx);
-        
+
         if (mem_avail_req > 0)
                 mem_avail_req -= min(mem_avail_req, freed);
-        
+
         if (mem_avail_req == 0) {
                 mem_avail_gen++;
                 condvar_broadcast(&mem_avail_cv);
         }
-        
+
         mutex_unlock(&mem_avail_mtx);
         interrupts_restore(ipl);
-        
+
         if (!(flags & FRAME_NO_RESERVE))
                 reserve_free(freed);
@@ -1024 +1024 @@
 {
         irq_spinlock_lock(&zones.lock, true);
-        
+
         /*
          * First, find host frame zone for addr.
          */
         size_t znum = find_zone(pfn, 1, 0);
-        
+
         assert(znum != (size_t) -1);
-        
+
         zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
-        
+
         irq_spinlock_unlock(&zones.lock, true);
 }
@@ -1043 +1043 @@
 {
         irq_spinlock_lock(&zones.lock, true);
-        
+
         for (size_t i = 0; i < count; i++) {
                 size_t znum = find_zone(start + i, 1, 0);
-                
+
                 if (znum == (size_t) -1)  /* PFN not found */
                         continue;
-                
+
                 zone_mark_unavailable(&zones.info[znum],
                     start + i - zones.info[znum].base);
         }
-        
+
         irq_spinlock_unlock(&zones.lock, true);
 }
@@ -1068 +1068 @@
                 condvar_initialize(&mem_avail_cv);
         }
-        
+
         /* Tell the architecture to create some memory */
         frame_low_arch_init();
-        
+
         if (config.cpu_active == 1) {
                 frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
@@ -1077 +1077 @@
                 frame_mark_unavailable(ADDR2PFN(KA2PA(config.stack_base)),
                     SIZE2FRAMES(config.stack_size));
-                
+
                 for (size_t i = 0; i < init.cnt; i++)
                         frame_mark_unavailable(ADDR2PFN(init.tasks[i].paddr),
                             SIZE2FRAMES(init.tasks[i].size));
-                
+
                 if (ballocs.size)
                         frame_mark_unavailable(ADDR2PFN(KA2PA(ballocs.base)),
                             SIZE2FRAMES(ballocs.size));
-                
+
                 /*
                  * Blacklist first frame, as allocating NULL would
@@ -1092 +1092 @@
                 frame_mark_unavailable(0, 1);
         }
-        
+
         frame_high_arch_init();
 }
@@ -1113 +1113 @@
 {
         uintptr_t limit = KA2PA(config.identity_base) + config.identity_size;
-        
+
         if (low) {
                 if (*basep > limit)
                         return false;
-                
+
                 if (*basep + *sizep > limit)
                         *sizep = limit - *basep;
@@ -1123 +1123 @@
                 if (*basep + *sizep <= limit)
                         return false;
-                
+
                 if (*basep <= limit) {
                         *sizep -= limit - *basep;
@@ -1129 +1129 @@
                 }
         }
-        
+
         return true;
 }
@@ -1139 +1139 @@
 {
         irq_spinlock_lock(&zones.lock, true);
-        
+
         uint64_t total = 0;
-        
+
         for (size_t i = 0; i < zones.count; i++)
                 total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
-        
+
         irq_spinlock_unlock(&zones.lock, true);
-        
+
         return total;
 }
@@ -1157 +1157 @@
         assert(busy != NULL);
         assert(free != NULL);
-        
+
         irq_spinlock_lock(&zones.lock, true);
-        
+
         *total = 0;
         *unavail = 0;
         *busy = 0;
         *free = 0;
-        
+
         for (size_t i = 0; i < zones.count; i++) {
                 *total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
-                
+
                 if (zones.info[i].flags & ZONE_AVAILABLE) {
                         *busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
@@ -1174 +1174 @@
                         *unavail += (uint64_t) FRAMES2SIZE(zones.info[i].count);
         }
-        
+
         irq_spinlock_unlock(&zones.lock, true);
 }
@@ -1190 +1190 @@
         printf("[nr] [base address    ] [frames    ] [flags ] [free frames ] [busy frames ]\n");
 #endif
-        
+
         /*
          * Because printing may require allocation of memory, we may not hold
@@ -1201 +1201 @@
          * the listing).
          */
-        
+
         size_t free_lowmem = 0;
         size_t free_highmem = 0;
         size_t free_highprio = 0;
-        
+
         for (size_t i = 0;; i++) {
                 irq_spinlock_lock(&zones.lock, true);
-                
+
                 if (i >= zones.count) {
                         irq_spinlock_unlock(&zones.lock, true);
                         break;
                 }
-                
+
                 pfn_t fbase = zones.info[i].base;
                 uintptr_t base = PFN2ADDR(fbase);
@@ -1220 +1220 @@
                 size_t free_count = zones.info[i].free_count;
                 size_t busy_count = zones.info[i].busy_count;
-                
+
                 bool available = ((flags & ZONE_AVAILABLE) != 0);
                 bool lowmem = ((flags & ZONE_LOWMEM) != 0);
                 bool highmem = ((flags & ZONE_HIGHMEM) != 0);
                 bool highprio = is_high_priority(fbase, count);
-                
+
                 if (available) {
                         if (lowmem)
                                 free_lowmem += free_count;
-                        
+
                         if (highmem)
                                 free_highmem += free_count;
-                        
+
                         if (highprio) {
                                 free_highprio += free_count;
@@ -1241 +1241 @@
                                  * statistics.
                                  */
-                                
+
                                 for (size_t index = 0; index < count; index++) {
                                         if (is_high_priority(fbase + index, 0)) {
@@ -1251 +1251 @@
                         }
                 }
-                
+
                 irq_spinlock_unlock(&zones.lock, true);
-                
+
                 printf("%-4zu", i);
-                
+
 #ifdef __32_BITS__
                 printf("  %p", (void *) base);
 #endif
-                
+
 #ifdef __64_BITS__
                 printf(" %p", (void *) base);
 #endif
-                
+
                 printf(" %12zu %c%c%c%c%c    ", count,
                     available ? 'A' : '-',
@@ -1270 +1270 @@
                     (flags & ZONE_LOWMEM) ? 'L' : '-',
                     (flags & ZONE_HIGHMEM) ? 'H' : '-');
-                
+
                 if (available)
                         printf("%14zu %14zu",
                             free_count, busy_count);
-                
+
                 printf("\n");
         }
-        
+
         printf("\n");
-        
+
         uint64_t size;
         const char *size_suffix;
-        
+
         bin_order_suffix(FRAMES2SIZE(free_lowmem), &size, &size_suffix,
             false);
         printf("Available low memory:    %zu frames (%" PRIu64 " %s)\n",
             free_lowmem, size, size_suffix);
-        
+
         bin_order_suffix(FRAMES2SIZE(free_highmem), &size, &size_suffix,
             false);
         printf("Available high memory:   %zu frames (%" PRIu64 " %s)\n",
             free_highmem, size, size_suffix);
-        
+
         bin_order_suffix(FRAMES2SIZE(free_highprio), &size, &size_suffix,
             false);
@@ -1308 +1308 @@
         irq_spinlock_lock(&zones.lock, true);
         size_t znum = (size_t) -1;
-        
+
         for (size_t i = 0; i < zones.count; i++) {
                 if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) {
@@ -1315 +1315 @@
                 }
         }
-        
+
         if (znum == (size_t) -1) {
                 irq_spinlock_unlock(&zones.lock, true);
@@ -1321 +1321 @@
                 return;
         }
-        
+
         size_t free_lowmem = 0;
         size_t free_highmem = 0;
         size_t free_highprio = 0;
-        
+
         pfn_t fbase = zones.info[znum].base;
         uintptr_t base = PFN2ADDR(fbase);
@@ -1332 +1332 @@
         size_t free_count = zones.info[znum].free_count;
         size_t busy_count = zones.info[znum].busy_count;
-        
+
         bool available = ((flags & ZONE_AVAILABLE) != 0);
         bool lowmem = ((flags & ZONE_LOWMEM) != 0);
         bool highmem = ((flags & ZONE_HIGHMEM) != 0);
         bool highprio = is_high_priority(fbase, count);
-        
+
         if (available) {
                 if (lowmem)
                         free_lowmem = free_count;
-                
+
                 if (highmem)
                         free_highmem = free_count;
-                
+
                 if (highprio) {
                         free_highprio = free_count;
@@ -1353 +1353 @@
                          * statistics.
                          */
-                        
+
                         for (size_t index = 0; index < count; index++) {
                                 if (is_high_priority(fbase + index, 0)) {
@@ -1363 +1363 @@
                 }
         }
-        
+
         irq_spinlock_unlock(&zones.lock, true);
-        
+
         uint64_t size;
         const char *size_suffix;
-        
+
         bin_order_suffix(FRAMES2SIZE(count), &size, &size_suffix, false);
-        
+
         printf("Zone number:             %zu\n", znum);
         printf("Zone base address:       %p\n", (void *) base);
@@ -1381 +1381 @@
             (flags & ZONE_LOWMEM) ? 'L' : '-',
             (flags & ZONE_HIGHMEM) ? 'H' : '-');
-        
+
         if (available) {
                 bin_order_suffix(FRAMES2SIZE(busy_count), &size, &size_suffix,
@@ -1387 +1387 @@
                 printf("Allocated space:         %zu frames (%" PRIu64 " %s)\n",
                     busy_count, size, size_suffix);
-                
+
                 bin_order_suffix(FRAMES2SIZE(free_count), &size, &size_suffix,
                     false);
                 printf("Available space:         %zu frames (%" PRIu64 " %s)\n",
                     free_count, size, size_suffix);
-                
+
                 bin_order_suffix(FRAMES2SIZE(free_lowmem), &size, &size_suffix,
                     false);
                 printf("Available low memory:    %zu frames (%" PRIu64 " %s)\n",
                     free_lowmem, size, size_suffix);
-                
+
                 bin_order_suffix(FRAMES2SIZE(free_highmem), &size, &size_suffix,
                     false);
                 printf("Available high memory:   %zu frames (%" PRIu64 " %s)\n",
                     free_highmem, size, size_suffix);
-                
+
                 bin_order_suffix(FRAMES2SIZE(free_highprio), &size, &size_suffix,
                     false);