Changes in kernel/arch/ia32/src/mm/frame.c [49ec568:dc0b964] in mainline

File:

• kernel/arch/ia32/src/mm/frame.c (modified) (5 diffs)

kernel/arch/ia32/src/mm/frame.c

@@ -46 +46 @@
 #include <print.h>
 
-#define PHYSMEM_LIMIT32  UINT64_C(0x100000000)
+#define PHYSMEM_LIMIT32  UINT64_C(0x07c000000)
+#define PHYSMEM_LIMIT64  UINT64_C(0x200000000)
 
 size_t hardcoded_unmapped_ktext_size = 0;
 size_t hardcoded_unmapped_kdata_size = 0;
 
-static void init_e820_memory(pfn_t minconf, bool low)
+uintptr_t last_frame = 0;
+
+static void init_e820_memory(pfn_t minconf)
 {
         unsigned int i;
         
         for (i = 0; i < e820counter; i++) {
-                uint64_t base64 = e820table[i].base_address;
-                uint64_t size64 = e820table[i].size;
-                
-#ifdef KARCH_ia32
+                uint64_t base = e820table[i].base_address;
+                uint64_t size = e820table[i].size;
+                
+#ifdef __32_BITS__
                 /*
-                 * Restrict the e820 table entries to 32-bits.
+                 * XXX FIXME:
+                 *
+                 * Ignore zones which start above PHYSMEM_LIMIT32
+                 * or clip zones which go beyond PHYSMEM_LIMIT32.
+                 *
+                 * The PHYSMEM_LIMIT32 (2 GB - 64 MB) is a rather
+                 * arbitrary constant which allows to have at
+                 * least 64 MB in the kernel address space to
+                 * map hardware resources.
+                 *
+                 * The kernel uses fixed 1:1 identity mapping
+                 * of the physical memory with 2:2 GB split.
+                 * This is a severe limitation of the current
+                 * kernel memory management.
+                 *
                  */
-                if (base64 >= PHYSMEM_LIMIT32)
+                
+                if (base > PHYSMEM_LIMIT32)
                         continue;
                 
-                if (base64 + size64 > PHYSMEM_LIMIT32)
-                        size64 = PHYSMEM_LIMIT32 - base64;
-#endif
-                
-                uintptr_t base = (uintptr_t) base64;
-                size_t size = (size_t) size64;
-                
-                if (!frame_adjust_zone_bounds(low, &base, &size))
+                if (base + size > PHYSMEM_LIMIT32)
+                        size = PHYSMEM_LIMIT32 - base;
+#endif
+                
+#ifdef __64_BITS__
+                /*
+                 * XXX FIXME:
+                 *
+                 * Ignore zones which start above PHYSMEM_LIMIT64
+                 * or clip zones which go beyond PHYSMEM_LIMIT64.
+                 *
+                 * The PHYSMEM_LIMIT64 (8 GB) is the size of the
+                 * fixed 1:1 identically mapped physical memory
+                 * accessible during the bootstrap process.
+                 * This is a severe limitation of the current
+                 * kernel memory management.
+                 *
+                 */
+                
+                if (base > PHYSMEM_LIMIT64)
                         continue;
+                
+                if (base + size > PHYSMEM_LIMIT64)
+                        size = PHYSMEM_LIMIT64 - base;
+#endif
                 
                 if (e820table[i].type == MEMMAP_MEMORY_AVAILABLE) {
@@ -82 +116 @@
                             FRAME_SIZE);
                         
+                        pfn_t pfn = ADDR2PFN(new_base);
                         size_t count = SIZE2FRAMES(new_size);
-                        pfn_t pfn = ADDR2PFN(new_base);
+                        
                         pfn_t conf;
-                        
-                        if (low) {
-                                if ((minconf < pfn) || (minconf >= pfn + count))
-                                        conf = pfn;
-                                else
-                                        conf = minconf;
-                                zone_create(pfn, count, conf,
-                                    ZONE_AVAILABLE | ZONE_LOWMEM);
-                        } else {
-                                conf = zone_external_conf_alloc(count);
-                                if (conf != 0)
-                                        zone_create(pfn, count, conf,
-                                            ZONE_AVAILABLE | ZONE_HIGHMEM);
-                        }
+                        if ((minconf < pfn) || (minconf >= pfn + count))
+                                conf = pfn;
+                        else
+                                conf = minconf;
+                        
+                        zone_create(pfn, count, conf, ZONE_AVAILABLE);
+                        
+                        // XXX this has to be removed
+                        if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
+                                last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
                 } else if ((e820table[i].type == MEMMAP_MEMORY_ACPI) ||
                     (e820table[i].type == MEMMAP_MEMORY_NVS)) {
@@ -148 +179 @@
 
 
-void frame_low_arch_init(void)
+void frame_arch_init(void)
 {
         pfn_t minconf;
@@ -161 +192 @@
 #endif
                 
-                init_e820_memory(minconf, true);
+                init_e820_memory(minconf);
                 
                 /* Reserve frame 0 (BIOS data) */
@@ -175 +206 @@
 }
 
-void frame_high_arch_init(void)
-{
-        if (config.cpu_active == 1)
-                init_e820_memory(0, false);
-}
-
 /** @}
  */