Changeset 5f7a0ef in mainline

Timestamp:

2008-07-06T19:47:48Z (17 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

498b201

Parents:

2ec725f

Message:

Introduce FRAME_LOW_16_GiB slab/frame allocator flag. When specified, the
allocators will not allocate memory above 16 GiB. Each architecture needs to
make sure not to merge zones from below and above 16 GiB. Allocations that
require memory below 16 GiB need to be altered to use this flag.

Location:

kernel/generic

Files:

• include/mm/frame.h (modified) (3 diffs)
• src/mm/frame.c (modified) (8 diffs)

kernel/generic/include/mm/frame.h

@@ -58 +58 @@
 #define ZONES_MAX               16
 
-/** If possible, merge with neighbouring zones. */
-#define ZONE_JOIN               0x1
-
 /** Convert the frame address to kernel va. */
 #define FRAME_KA                0x1
 /** Do not panic and do not sleep on failure. */
-#define FRAME_ATOMIC            0x2
+#define FRAME_ATOMIC            0x2
 /** Do not start reclaiming when no free memory. */
-#define FRAME_NO_RECLAIM        0x4
+#define FRAME_NO_RECLAIM        0x4
+/** Do not allocate above 16GiB. */
+#define FRAME_LOW_16_GiB        0x8
 
 static inline uintptr_t PFN2ADDR(pfn_t frame)
@@ -91 +90 @@
 
 #define IS_BUDDY_ORDER_OK(index, order)         \
-        ((~(((unative_t) -1) << (order)) & (index)) == 0)
+    ((~(((unative_t) -1) << (order)) & (index)) == 0)
 #define IS_BUDDY_LEFT_BLOCK(zone, frame)        \
-        (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
 #define IS_BUDDY_RIGHT_BLOCK(zone, frame)       \
-        (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
+    (((frame_index((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
 #define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame)    \
-        (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 0)
 #define IS_BUDDY_RIGHT_BLOCK_ABS(zone, frame)   \
-        (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
+    (((frame_index_abs((zone), (frame)) >> (frame)->buddy_order) & 0x1) == 1)
 
 #define frame_alloc(order, flags)               \
-        frame_alloc_generic(order, flags, NULL)
+    frame_alloc_generic(order, flags, NULL)
 
 extern void frame_init(void);
-extern void *frame_alloc_generic(uint8_t order, int flags, unsigned int *pzone);
-extern void frame_free(uintptr_t frame);
-extern void frame_reference_add(pfn_t pfn);
+extern void *frame_alloc_generic(uint8_t, int, unsigned int *);
+extern void frame_free(uintptr_t);
+extern void frame_reference_add(pfn_t);
 
-extern int zone_create(pfn_t start, count_t count, pfn_t confframe, int flags);
-extern void *frame_get_parent(pfn_t frame, unsigned int hint);
-extern void frame_set_parent(pfn_t frame, void *data, unsigned int hint);
-extern void frame_mark_unavailable(pfn_t start, count_t count);
-extern uintptr_t zone_conf_size(count_t count);
-extern void zone_merge(unsigned int z1, unsigned int z2);
+extern int zone_create(pfn_t, count_t, pfn_t, int);
+extern void *frame_get_parent(pfn_t, unsigned int);
+extern void frame_set_parent(pfn_t, void *, unsigned int);
+extern void frame_mark_unavailable(pfn_t, count_t);
+extern uintptr_t zone_conf_size(count_t);
+extern void zone_merge(unsigned int, unsigned int);
 extern void zone_merge_all(void);
 extern uint64_t zone_total_size(void);
@@ -122 +121 @@
  */
 extern void zone_print_list(void);
-extern void zone_print_one(unsigned int znum);
+extern void zone_print_one(unsigned int);
 
 #endif

kernel/generic/src/mm/frame.c

@@ -201 +201 @@
 }
 
-/**
- * Try to find a zone where can we find the frame.
+/** Try to find a zone where can we find the frame.
  *
  * Assume interrupts are disabled.
@@ -238 +237 @@
                 if (i >= zones.count)
                         i = 0;
-        } while(i != hint);
+        } while (i != hint);
 
         spinlock_unlock(&zones.lock);
@@ -255 +254 @@
  *
  * @param order         Size (2^order) of free space we are trying to find.
+ * @param flags         Required flags of the target zone.
  * @param pzone         Pointer to preferred zone or NULL, on return contains
  *                      zone number.
  */
-static zone_t *find_free_zone_and_lock(uint8_t order, unsigned int *pzone)
+static zone_t *
+find_free_zone_and_lock(uint8_t order, int flags, unsigned int *pzone)
 {
         unsigned int i;
@@ -264 +265 @@
         unsigned int hint = pzone ? *pzone : 0;
         
+        /* Mask off flags that are not applicable. */
+        flags &= FRAME_LOW_16_GiB;
+
         spinlock_lock(&zones.lock);
         if (hint >= zones.count)
@@ -273 +277 @@
                 spinlock_lock(&z->lock);
 
-                /* Check if the zone has 2^order frames area available  */
-                if (zone_can_alloc(z, order)) {
-                        spinlock_unlock(&zones.lock);
-                        if (pzone)
-                                *pzone = i;
-                        return z;
+                /*
+                 * Check whether the zone meets the search criteria.
+                 */
+                if ((z->flags & flags) == flags) {
+                        /*
+                         * Check if the zone has 2^order frames area available.
+                         */
+                        if (zone_can_alloc(z, order)) {
+                                spinlock_unlock(&zones.lock);
+                                if (pzone)
+                                        *pzone = i;
+                                return z;
+                        }
                 }
                 spinlock_unlock(&z->lock);
                 if (++i >= zones.count)
                         i = 0;
-        } while(i != hint);
+        } while (i != hint);
         spinlock_unlock(&zones.lock);
         return NULL;
@@ -811 +822 @@
         z->base = start;
         z->count = count;
+
+        /* Mask off flags that are calculated automatically. */
+        flags &= ~FRAME_LOW_16_GiB;
+        /* Determine calculated flags. */
+        if (z->base + count < (1ULL << (34 - FRAME_WIDTH)))     /* 16 GiB */
+                flags |= FRAME_LOW_16_GiB;
+
         z->flags = flags;
+
         z->free_count = count;
         z->busy_count = 0;
@@ -983 +1002 @@
          * First, find suitable frame zone.
          */
-        zone = find_free_zone_and_lock(order, pzone);
+        zone = find_free_zone_and_lock(order, flags, pzone);
         
         /* If no memory, reclaim some slab memory,
@@ -990 +1009 @@
                 freed = slab_reclaim(0);
                 if (freed)
-                        zone = find_free_zone_and_lock(order, pzone);
+                        zone = find_free_zone_and_lock(order, flags, pzone);
                 if (!zone) {
                         freed = slab_reclaim(SLAB_RECLAIM_ALL);
                         if (freed)
-                                zone = find_free_zone_and_lock(order, pzone);
+                                zone = find_free_zone_and_lock(order, flags,
+                                    pzone);
                 }
         }