Changeset b0c2075 in mainline for kernel/generic/include

Timestamp:

2013-09-10T17:48:57Z (12 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

85147f3

Parents:

86733f3

Message:

new physical memory allocator supporting physical address constrains
the buddy allocator framework is retired and replaced by a two-level bitmap
the allocator can allocate an arbitrary number of frames, not only a power-of-two count

Caution: Change of semantics
The physical memory allocator no longer allocates naturally aligned blocks. If you require an aligned block, specify it as the constraint.

Location:

kernel/generic/include

Files:

• config.h (modified) (1 diff)
• macros.h (modified) (1 diff)
• mm/buddy.h (deleted)
• mm/frame.h (modified) (3 diffs)
• mm/slab.h (modified) (2 diffs)

kernel/generic/include/config.h

@@ -37 +37 @@
 
 #include <arch/mm/page.h>
+#include <macros.h>
 
-#define ONE_FRAME    0
-#define TWO_FRAMES   1
-#define FOUR_FRAMES  2
-
-#define STACK_FRAMES  TWO_FRAMES
-#define STACK_SIZE    ((1 << STACK_FRAMES) << PAGE_WIDTH)
+#define STACK_FRAMES  2
+#define STACK_SIZE    FRAMES2SIZE(STACK_FRAMES)
 
 #define STACK_SIZE_USER  (1 * 1024 * 1024)

kernel/generic/include/macros.h

@@ -117 +117 @@
         overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
 
+#define PFN2ADDR(frame)  ((frame) << FRAME_WIDTH)
+#define ADDR2PFN(addr)   ((addr) >> FRAME_WIDTH)
+
+#define FRAMES2SIZE(frames)  ((frames) << FRAME_WIDTH)
+#define SIZE2FRAMES(size) \
+        (((size) == 0) ? 0 : ((((size) - 1) >> FRAME_WIDTH) + 1))
+
 #define KiB2SIZE(kb)  ((kb) << 10)
 #define MiB2SIZE(mb)  ((mb) << 20)

kernel/generic/include/mm/frame.h

@@ -39 +39 @@
 #include <typedefs.h>
 #include <trace.h>
+#include <adt/bitmap.h>
 #include <adt/list.h>
-#include <mm/buddy.h>
 #include <synch/spinlock.h>
 #include <arch/mm/page.h>
@@ -90 +90 @@
 
 typedef struct {
-        size_t refcount;      /**< Tracking of shared frames */
-        link_t buddy_link;    /**< Link to the next free block inside
-                                   one order */
-        void *parent;         /**< If allocated by slab, this points there */
-        uint8_t buddy_order;  /**< Buddy system block order */
+        size_t refcount;  /**< Tracking of shared frames */
+        void *parent;     /**< If allocated by slab, this points there */
 } frame_t;
 
 typedef struct {
-        pfn_t base;                    /**< Frame_no of the first frame
-                                            in the frames array */
-        size_t count;                  /**< Size of zone */
-        size_t free_count;             /**< Number of free frame_t
-                                            structures */
-        size_t busy_count;             /**< Number of busy frame_t
-                                            structures */
-        zone_flags_t flags;            /**< Type of the zone */
+        /** Frame_no of the first frame in the frames array */
+        pfn_t base;
         
-        frame_t *frames;               /**< Array of frame_t structures
-                                            in this zone */
-        buddy_system_t *buddy_system;  /**< Buddy system for the zone */
+        /** Size of zone */
+        size_t count;
+        
+        /** Number of free frame_t structures */
+        size_t free_count;
+        
+        /** Number of busy frame_t structures */
+        size_t busy_count;
+        
+        /** Type of the zone */
+        zone_flags_t flags;
+        
+        /** Frame bitmap */
+        bitmap_t bitmap;
+        
+        /** Array of frame_t structures in this zone */
+        frame_t *frames;
 } zone_t;
 
@@ -124 +129 @@
 extern zones_t zones;
 
-NO_TRACE static inline uintptr_t PFN2ADDR(pfn_t frame)
-{
-        return (uintptr_t) (frame << FRAME_WIDTH);
-}
-
-NO_TRACE static inline pfn_t ADDR2PFN(uintptr_t addr)
-{
-        return (pfn_t) (addr >> FRAME_WIDTH);
-}
-
-NO_TRACE static inline size_t SIZE2FRAMES(size_t size)
-{
-        if (size == 0)
-                return 0;
-        
-        return (size_t) ((size - 1) >> FRAME_WIDTH) + 1;
-}
-
-NO_TRACE static inline size_t FRAMES2SIZE(size_t frames)
-{
-        return (size_t) (frames << FRAME_WIDTH);
-}
-
-#define IS_BUDDY_ORDER_OK(index, order) \
-    ((~(((sysarg_t) -1) << (order)) & (index)) == 0)
-#define IS_BUDDY_LEFT_BLOCK(zone, frame) \
-    (((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)
-#define IS_BUDDY_LEFT_BLOCK_ABS(zone, frame) \
-    (((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)
-
 extern void frame_init(void);
 extern bool frame_adjust_zone_bounds(bool, uintptr_t *, size_t *);
-extern uintptr_t frame_alloc_generic(uint8_t, frame_flags_t, uintptr_t, size_t *);
-extern uintptr_t frame_alloc(uint8_t, frame_flags_t, uintptr_t);
-extern uintptr_t frame_alloc_noreserve(uint8_t, frame_flags_t, uintptr_t);
+extern uintptr_t frame_alloc_generic(size_t, frame_flags_t, uintptr_t, size_t *);
+extern uintptr_t frame_alloc(size_t, frame_flags_t, uintptr_t);
+extern uintptr_t frame_alloc_noreserve(size_t, frame_flags_t, uintptr_t);
 extern void frame_free_generic(uintptr_t, frame_flags_t);
 extern void frame_free(uintptr_t);

kernel/generic/include/mm/slab.h

@@ -55 +55 @@
 /** Maximum wasted space we allow for cache */
 #define SLAB_MAX_BADNESS(cache) \
-        (((unsigned int) PAGE_SIZE << (cache)->order) >> 2)
+        (FRAMES2SIZE((cache)->frames) >> 2)
 
 /* slab_reclaim constants */
@@ -101 +101 @@
         
         /* Computed values */
-        uint8_t order;   /**< Order of frames to be allocated */
+        size_t frames;   /**< Number of frames to be allocated */
         size_t objects;  /**< Number of objects that fit in */