Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/ia32/src/mm/frame.c

    r49ec568 rdc0b964  
    4646#include <print.h>
    4747
    48 #define PHYSMEM_LIMIT32  UINT64_C(0x100000000)
     48#define PHYSMEM_LIMIT32  UINT64_C(0x07c000000)
     49#define PHYSMEM_LIMIT64  UINT64_C(0x200000000)
    4950
    5051size_t hardcoded_unmapped_ktext_size = 0;
    5152size_t hardcoded_unmapped_kdata_size = 0;
    5253
    53 static void init_e820_memory(pfn_t minconf, bool low)
     54uintptr_t last_frame = 0;
     55
     56static void init_e820_memory(pfn_t minconf)
    5457{
    5558        unsigned int i;
    5659       
    5760        for (i = 0; i < e820counter; i++) {
    58                 uint64_t base64 = e820table[i].base_address;
    59                 uint64_t size64 = e820table[i].size;
    60                
    61 #ifdef KARCH_ia32
     61                uint64_t base = e820table[i].base_address;
     62                uint64_t size = e820table[i].size;
     63               
     64#ifdef __32_BITS__
    6265                /*
    63                  * Restrict the e820 table entries to 32-bits.
     66                 * XXX FIXME:
     67                 *
     68                 * Ignore zones which start above PHYSMEM_LIMIT32
     69                 * or clip zones which go beyond PHYSMEM_LIMIT32.
     70                 *
     71                 * The PHYSMEM_LIMIT32 (2 GB - 64 MB) is a rather
     72                 * arbitrary constant which allows to have at
     73                 * least 64 MB in the kernel address space to
     74                 * map hardware resources.
     75                 *
     76                 * The kernel uses fixed 1:1 identity mapping
     77                 * of the physical memory with 2:2 GB split.
     78                 * This is a severe limitation of the current
     79                 * kernel memory management.
     80                 *
    6481                 */
    65                 if (base64 >= PHYSMEM_LIMIT32)
     82               
     83                if (base > PHYSMEM_LIMIT32)
    6684                        continue;
    6785               
    68                 if (base64 + size64 > PHYSMEM_LIMIT32)
    69                         size64 = PHYSMEM_LIMIT32 - base64;
    70 #endif
    71                
    72                 uintptr_t base = (uintptr_t) base64;
    73                 size_t size = (size_t) size64;
    74                
    75                 if (!frame_adjust_zone_bounds(low, &base, &size))
     86                if (base + size > PHYSMEM_LIMIT32)
     87                        size = PHYSMEM_LIMIT32 - base;
     88#endif
     89               
     90#ifdef __64_BITS__
     91                /*
     92                 * XXX FIXME:
     93                 *
     94                 * Ignore zones which start above PHYSMEM_LIMIT64
     95                 * or clip zones which go beyond PHYSMEM_LIMIT64.
     96                 *
     97                 * The PHYSMEM_LIMIT64 (8 GB) is the size of the
     98                 * fixed 1:1 identically mapped physical memory
     99                 * accessible during the bootstrap process.
     100                 * This is a severe limitation of the current
     101                 * kernel memory management.
     102                 *
     103                 */
     104               
     105                if (base > PHYSMEM_LIMIT64)
    76106                        continue;
     107               
     108                if (base + size > PHYSMEM_LIMIT64)
     109                        size = PHYSMEM_LIMIT64 - base;
     110#endif
    77111               
    78112                if (e820table[i].type == MEMMAP_MEMORY_AVAILABLE) {
     
    82116                            FRAME_SIZE);
    83117                       
     118                        pfn_t pfn = ADDR2PFN(new_base);
    84119                        size_t count = SIZE2FRAMES(new_size);
    85                         pfn_t pfn = ADDR2PFN(new_base);
     120                       
    86121                        pfn_t conf;
    87                        
    88                         if (low) {
    89                                 if ((minconf < pfn) || (minconf >= pfn + count))
    90                                         conf = pfn;
    91                                 else
    92                                         conf = minconf;
    93                                 zone_create(pfn, count, conf,
    94                                     ZONE_AVAILABLE | ZONE_LOWMEM);
    95                         } else {
    96                                 conf = zone_external_conf_alloc(count);
    97                                 if (conf != 0)
    98                                         zone_create(pfn, count, conf,
    99                                             ZONE_AVAILABLE | ZONE_HIGHMEM);
    100                         }
     122                        if ((minconf < pfn) || (minconf >= pfn + count))
     123                                conf = pfn;
     124                        else
     125                                conf = minconf;
     126                       
     127                        zone_create(pfn, count, conf, ZONE_AVAILABLE);
     128                       
     129                        // XXX this has to be removed
     130                        if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
     131                                last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
    101132                } else if ((e820table[i].type == MEMMAP_MEMORY_ACPI) ||
    102133                    (e820table[i].type == MEMMAP_MEMORY_NVS)) {
     
    148179
    149180
    150 void frame_low_arch_init(void)
     181void frame_arch_init(void)
    151182{
    152183        pfn_t minconf;
     
    161192#endif
    162193               
    163                 init_e820_memory(minconf, true);
     194                init_e820_memory(minconf);
    164195               
    165196                /* Reserve frame 0 (BIOS data) */
     
    175206}
    176207
    177 void frame_high_arch_init(void)
    178 {
    179         if (config.cpu_active == 1)
    180                 init_e820_memory(0, false);
    181 }
    182 
    183208/** @}
    184209 */
Note: See TracChangeset for help on using the changeset viewer.