src/memory/alloc4k.hpp

Idź do dokumentacji tego pliku.

/*header file for src/memory/alloc4k.cpp*/

#ifndef _CORE_MEMORY_ALLOC4K_HPP
#define _CORE_MEMORY_ALLOC4K_HPP

/*necessary includes*/
#include "src/common/stack.hpp"
#include "src/ipc/lock.hpp"
#include "src/memory/zone.hpp"

//change a physical value to a virtual, for the early kernel data by adding 0xc0000000-0x100000
#define LMA2VIRT(obj)           ((uint32)(obj)+mem_kernel_start-mem_physical)

/*from the linker script*/
extern char bss;
extern char bss2;
extern char bssend;
extern char end;

/*the way we divide the address space*/
const uint32 mem_trap_lower     = 0;            /*the lower null-pointer trap*/
const uint32 mem_user_start     = 0x00001000;   /*start of user level*/
const uint32 mem_low_start      = 0x00001000;   /*start of physical low page area*/
//could be 0xa0000- which is the begging of graphics card graphics mode buffer,
//but there are 32kib of EBDA from 640kib downwards which we don't want to overwrite.
const uint32 video_memory       = 0xb8000;      /*doh, this is remapped into kernel space early*/
const uint32 mem_low_end        = 0x00098000;   /*end of low pages area*/
const uint32 mem_user_end       = 0xbfffffff;   /*end of user level*/
const uint32 mem_user_load      = 0x80000000;   /*place to load modules/executables*/
const uint32 mem_exec           = 0x80000000;   /*place to start execution*/
const uint32 mem_kernel_start   = 0xc0000000;   /*start of kernel level*/
const uint32 mem_kernel_end     = 0xffffffff;   /*end of kernel level*/
const uint32 mem_heap_start     = 0xd0000000;   /*start of kernel heap*/
const uint32 mem_heap_end       = 0xf0000000;   /*end of kernel heap*/
const uint32 mem_pgd_start      = 0xFF800000;   /*the start of the space's page tables*/
const uint32 mem_pgt_start      = 0xFFBFFFFF;   /*the end of the space's page tables*/
const uint32 mem_trap_upper     = 0xfffff000;   /*the upper null-pointer trap*/
const uint32 mem_space_start    = mem_user_start;/*where the memory map starts*/
const uint32 mem_space_end      = mem_kernel_start;/*where a user memory map ends*/
const uint32 mem_space_krnend   = mem_heap_start;/*where the kmem kernel memory map ends*/
const uint32 mem_physical       = 0x00100000;   /*load address of the kernel*/

/*memory size*/
const size_t mem_4k             = 4096;
const size_t mem_1Mib           = 0x100000;
const size_t PAGE_SIZE          = 4096;
const size_t PGT_WIDE           = 4 * mem_1Mib; //how wide does a pgt map memory? 4 Mib
const size_t memory_size        = mem_1Mib * 32;
const uint32 mem_ksize          = ((uint32) &end - mem_kernel_start);   /*kernel's size*/

namespace Memory {
namespace Physical {

void init();    /*init the free-page stack*/

/*======================balloc*/
extern uint32 heap_area_addend; /*how many virtual bytes are occupied before the heap*/
extern bool balloc_on;  /*is it still on?*/
extern uint32 first_free_page;  /*the first page to be used*/
extern IPC::Lock::lock_t lock_ZeroVirtFrame;
extern void *ZeroVirtFrame;

extern class Memory::zone free_pages_high ;     /*all pages in the high area, to be allocated*/
extern class Memory::zone free_pages_low;       /*all pages in the low area, to be allocated*/

const uint32 PAGESCLEANMAX              = 0x20; //how many pages may be stored at a time, in the buffer
extern class Memory::zone zero_pages_high ;     /*all pages in the high area, to be allocated, which have already been cleared*/
extern class Memory::zone zero_pages_low;       /*all pages in the low area, to be allocated, which have already been cleared*/


addr_t ballocate (size_t size, uint32 alignment);       /*bootup malloc: virtual allocs on the heap space*/
void disable_balloc();  /*disable it*/

/*======================free pages allocation*/
addr_t allocate_page_high (uint32 cnt); /*allocate from the upper pool*/
addr_t allocate_page_low (uint32 cnt);  /*allocate from the lower pool*/
addr_t alloc4kDirty_high(uint32 cnt);   /*reads a page from the dirty list, zeroes it*/
addr_t alloc4kDirty_low(uint32 cnt);    /*reads a page from the dirty list, zeroes it*/
int free_page_high(addr_t physical);    /*free a page to upper pool*/
int free_page_low(addr_t physical);     /*free a page to lower pool*/

/*=====================memory capacity*/
size_t get_memory_size();               /*returns all mem*/
size_t get_high_memory_size();          /*returns above 1Mib*/

  };    /*namespace Physical*/
 };     /*namespace Memory*/

int disalloc4k(addr_t physical);        /*free a page; the page is then saved to the dirty page list*/
addr_t alloc4k(uint32 cnt,bool fatal);  /*get me a page! if fatal, will panic on out-of-memory. allocates a clean page*/

#endif

---