Changes in kernel/generic/include/mm/frame.h [5df1963:aaceebc4] in mainline

File:

• kernel/generic/include/mm/frame.h (modified) (4 diffs)

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>
@@ -50 +50 @@
 typedef uint8_t frame_flags_t;
 
-#define FRAME_NONE        0x00
+#define FRAME_NONE        0x0
+/** Convert the frame address to kernel VA. */
+#define FRAME_KA          0x1
 /** Do not panic and do not sleep on failure. */
-#define FRAME_ATOMIC      0x01
+#define FRAME_ATOMIC      0x2
 /** Do not start reclaiming when no free memory. */
-#define FRAME_NO_RECLAIM  0x02
+#define FRAME_NO_RECLAIM  0x4
 /** Do not reserve / unreserve memory. */
-#define FRAME_NO_RESERVE  0x04
+#define FRAME_NO_RESERVE  0x8
 /** Allocate a frame which can be identity-mapped. */
-#define FRAME_LOWMEM      0x08
+#define FRAME_LOWMEM      0x10
 /** Allocate a frame which cannot be identity-mapped. */
-#define FRAME_HIGHMEM     0x10
+#define FRAME_HIGHMEM     0x20
+/** Allocate a frame which needs to be from DMA zone. */
+#define FRAME_DMA         0x40
 
 typedef uint8_t zone_flags_t;
 
-#define ZONE_NONE       0x00
+#define ZONE_NONE       0x0
 /** Available zone (free for allocation) */
-#define ZONE_AVAILABLE  0x01
+#define ZONE_AVAILABLE  0x1
 /** Zone is reserved (not available for allocation) */
-#define ZONE_RESERVED   0x02
+#define ZONE_RESERVED   0x2
 /** Zone is used by firmware (not available for allocation) */
-#define ZONE_FIRMWARE   0x04
+#define ZONE_FIRMWARE   0x4
 /** Zone contains memory that can be identity-mapped */
-#define ZONE_LOWMEM     0x08
+#define ZONE_LOWMEM     0x8
 /** Zone contains memory that cannot be identity-mapped */
-#define ZONE_HIGHMEM    0x10
+#define ZONE_HIGHMEM    0x10
+/** Zone contains memory suitable for old ISA DMA */
+#define ZONE_DMA        0x20
 
 /** Mask of zone bits that must be matched exactly. */
-#define ZONE_EF_MASK  0x07
+#define ZONE_EF_MASK    0x7
 
-#define FRAME_TO_ZONE_FLAGS(ff) \
-        ((((ff) & FRAME_LOWMEM) ? ZONE_LOWMEM : \
+#define FRAME_TO_ZONE_FLAGS(ff) \
+        ((((ff) & FRAME_DMA) ? ZONE_DMA : \
+            (((ff) & FRAME_LOWMEM) ? ZONE_LOWMEM : \
             (((ff) & FRAME_HIGHMEM) ? ZONE_HIGHMEM : \
-            ZONE_LOWMEM /* | ZONE_HIGHMEM */)) | \
+            ZONE_LOWMEM /* | ZONE_HIGHMEM */))) | \
             ZONE_AVAILABLE)
 
@@ -90 +97 @@
 
 typedef struct {
-        size_t refcount;  /**< Tracking of shared frames */
-        void *parent;     /**< If allocated by slab, this points there */
+        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 */
 } frame_t;
 
 typedef struct {
-        /** Frame_no of the first frame in the frames array */
-        pfn_t base;
+        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 */
         
-        /** 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;
+        frame_t *frames;               /**< Array of frame_t structures
+                                            in this zone */
+        buddy_system_t *buddy_system;  /**< Buddy system for the zone */
 } zone_t;
 
@@ -129 +131 @@
 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)
+                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(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, size_t, frame_flags_t);
-extern void frame_free(uintptr_t, size_t);
-extern void frame_free_noreserve(uintptr_t, size_t);
+extern void *frame_alloc_generic(uint8_t, frame_flags_t, size_t *);
+extern void *frame_alloc(uint8_t, frame_flags_t);
+extern void *frame_alloc_noreserve(uint8_t, frame_flags_t);
+extern void frame_free_generic(uintptr_t, frame_flags_t);
+extern void frame_free(uintptr_t);
+extern void frame_free_noreserve(uintptr_t);
 extern void frame_reference_add(pfn_t);
 extern size_t frame_total_free_get(void);