src/memory/alloc4k.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       alloc4k.cpp, version 1.0                           *
************************************************************
*                                                          *
*here is a great part of the low-level part machinerie     *
*because this is the heart of physical page allocating,    *
*management and division.                                  *
*                                                          *
*23'04'04- first revision (1.0)                            *
*                                                          *
*based on 0.05 branch's alloc4k.cpp                        *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/error.hpp"
#include "src/tty/teletype.hpp"
#include "src/ipc/lock.hpp"
#include "src/thread/thread.hpp"
#include "src/thread/scheduler.hpp"
#include "src/memory/align.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/pager.hpp"
#include "src/memory/zone.hpp"
#include "src/memory/alloc4k.hpp"

namespace Memory {
namespace Physical {


uint32 heap_area_addend = 0;    /*how many virtual bytes are occupied before the heap*/
bool balloc_on=TRUE;            /*is it still on?*/
class Memory::zone free_pages_high ;    /*all pages in the high area, to be allocated*/
class Memory::zone free_pages_low;      /*all pages in the low area, to be allocated*/
class Memory::zone zero_pages_high ;    /*all pages in the high area, to be allocated, which have already been cleared*/
class Memory::zone zero_pages_low ;     /*all pages in the low area, to be allocated, which have already been cleared*/

IPC::Lock::lock_t lock_pages(const_cast<char*>("pages"));               /*lock on free page lists*/
uint32 first_free_page=(mem_ksize+mem_physical)/PAGE_SIZE;/*the first page to be used*/

IPC::Lock::lock_t lock_ZeroVirtFrame(const_cast<char*>("ZeroVirtFrame"));
void *ZeroVirtFrame;


/*init the free-page stack*/
void init()
 {
uint32 stack_size; uint32 *stack_addr;
uint32 n,i;
/* CREATE ZeroVirtFrame */
        ZeroVirtFrame= (void*)Memory::Physical::ballocate(PAGE_SIZE, PAGE_ALIGN);
/* INIT THE ZERO PAGE STACKS*/
/*allocate some space for the stack*/
        stack_size = PAGESCLEANMAX*2;
        stack_addr = (uint32*)ballocate(stack_size*sizeof(uint32), PAGE_ALIGN);
/*allocate physical pages to the space*/
        for (i=0;i<stack_size*sizeof(uint32);i+=PAGE_SIZE)
                Memory::Pager::kmem.pte_map(i+(uint32)stack_addr, (first_free_page*PAGE_SIZE+i)|PTE_PRESENT|PTE_WRITEABLE);
/*increase the counter because we used some pages*/
        first_free_page+=align_up(stack_size*sizeof(uint32),PAGE_ALIGN)/PAGE_SIZE;

        zero_pages_low.init(stack_addr, PAGESCLEANMAX, PAGE_SIZE);
        zero_pages_high.init(stack_addr+PAGESCLEANMAX, PAGESCLEANMAX, PAGE_SIZE);

/*INIT THE HIGHMEM FREE PAGES STACK*/
size_t high_mem;
size_t last_page;
/*get mem size*/
        high_mem= get_high_memory_size();
        last_page=get_memory_size() - PAGE_SIZE;
/*allocate some space for the stack*/
        stack_size = 0x10+high_mem/PAGE_SIZE;   /*for extra frees*/
        stack_addr = (uint32*)ballocate(stack_size*sizeof(uint32), PAGE_ALIGN);
/*allocate physical pages to the space*/
        for (i=0;i<stack_size*sizeof(uint32);i+=PAGE_SIZE)
                Memory::Pager::kmem.pte_map(i+(uint32)stack_addr, (first_free_page*PAGE_SIZE+i)|PTE_PRESENT|PTE_WRITEABLE);
/*increase the counter because we used some pages*/
        first_free_page+=align_up(stack_size*sizeof(uint32),PAGE_ALIGN)/PAGE_SIZE;
        free_pages_high.init((uint32*)stack_addr, stack_size, PAGE_SIZE);
/*fill in with the proper values, downwards*/
        i=0;
        for (n=last_page; n>=first_free_page*PAGE_SIZE; n-=PAGE_SIZE) {
                stack_addr[i]=n;
                i++; };
        free_pages_high.set_length(i);

/*INIT THE LOWMEM FREE PAGES STACK*/
/*let's take space from 0x0000_1000-0x0009_ffff*/
        stack_size=((mem_low_end-mem_low_start)>>12)+0x10;      /*for extra frees*/
        stack_addr=(uint32*)ballocate(stack_size*sizeof(uint32),PAGE_ALIGN);
//      cout("\nfree_pages_low stack_addr=");cout((uint32)stack_addr);
//      cout("\nstack_size=");cout(stack_size);
/*allocate physical pages to the space*/
        for (i=0;i<stack_size*sizeof(uint32);i+=PAGE_SIZE)
                Memory::Pager::kmem.pte_map(i+(uint32)stack_addr, alloc4k(1,true)|PTE_PRESENT|PTE_WRITEABLE);
//      cout("\nphys=");cout(Memory::Pager::kmem.pte_val((uint32)stack_addr&0xfffff000));
/*increase the counter because we used some pages*/
        first_free_page+=align_up(stack_size*sizeof(uint32),PAGE_ALIGN)/PAGE_SIZE;
        free_pages_low.init((uint32*)stack_addr, stack_size, PAGE_SIZE);
/*fill in with the proper values, downwards*/
        i=0;
        for (n=mem_low_end-PAGE_SIZE;n>=mem_low_start; n-=PAGE_SIZE) {
                stack_addr[i]=n;
                i++; };
//      cout("\n&stack_addr[i]=");cout((uint32)&stack_addr[i]);
        free_pages_low.set_length(i);
 }

/*bootup malloc: virtual allocs on the heap space*/
addr_t ballocate (size_t size, uint32 alignment)
 {
addr_t ret;
/*sanity*/
        if (balloc_on == false)
                sysfail("not permitted");

/*get a proper alignment*/
        heap_area_addend = align_up(heap_area_addend,alignment);
/*increase counter*/
        ret = (addr_t) (heap_area_addend + mem_heap_start);
        heap_area_addend += size;

        return ret;
 }

/*disable it*/
void disable_balloc() {
        balloc_on=FALSE;
 }

/*allocate from the upper pool*/
addr_t allocate_page_high (uint32 cnt)
 {
addr_t ret;
        ret= zero_pages_high.alloc(cnt);
        if (ret==NULL)
                ret= alloc4kDirty_high(cnt);

        return ret;
 }

/*allocate from the lower pool*/
addr_t allocate_page_low (uint32 cnt)
 {
addr_t ret;
        ret= zero_pages_low.alloc(cnt);
        if (ret==NULL)
                ret= alloc4kDirty_low(cnt);

        return ret;
 }

/*reads a page from the dirty list, zeroes it*/
addr_t alloc4kDirty_high(uint32 cnt)
 {
addr_t ret;
uint32 i;
        ret= free_pages_high.alloc(cnt);
        if (ret==NULL)
                return NULL;
        for (i=0;i<cnt;i++)
         {
                Memory::Pager::FrameAssign(ZeroVirtFrame, &lock_ZeroVirtFrame, ret+i);
                memset(ZeroVirtFrame,0,PAGE_SIZE);
                Memory::Pager::FrameRelease(&lock_ZeroVirtFrame);
         }

        return ret;
 }

/*reads a page from the dirty list, zeroes it*/
addr_t alloc4kDirty_low(uint32 cnt)
 {
addr_t ret;
uint32 i;
        ret= free_pages_low.alloc(cnt);
        if (ret==NULL)
                return NULL;
        for (i=0;i<cnt;i++)
         {
                Memory::Pager::FrameAssign(ZeroVirtFrame, &lock_ZeroVirtFrame, ret+i);
                memset(ZeroVirtFrame,0,PAGE_SIZE);
                Memory::Pager::FrameRelease(&lock_ZeroVirtFrame);
         }

        return ret;
 }

/*free a page to upper pool*/
int free_page_high(addr_t physical) {
        if (physical < mem_1Mib) complain("bad page freed");
        return free_pages_high.free(physical);
 }

/*free a page to lower pool*/
int free_page_low(addr_t physical) {
        if (physical > 0xa0000) complain("bad page freed");
        if (physical == 0) complain("null page freed");
        return free_pages_low.free(physical);
 }

/*=====================memory capacity*/
/*returns all mem*/
size_t get_memory_size() {
        return memory_size;
 }

/*returns above 1Mib*/
size_t get_high_memory_size() {
        return memory_size - mem_1Mib;
 }


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

/*get me a page!*/
addr_t alloc4k(uint32 cnt, bool fatal)
 {
addr_t ret;
        ret=Memory::Physical::allocate_page_high(cnt);
        if ((ret == NULL) || (ret == 0xffffffff))
                ret=Memory::Physical::allocate_page_low(cnt);
        if ((ret == NULL) || (ret==0xffffffff))
                if (fatal)
                        sysfail("alloc4k: out of memory");

        return ret;
 }

/*free a page*/
int disalloc4k(addr_t physical)
 {
        return 1;
/*free and put into one of the pools*/
        if (physical < mem_1Mib)
                return Memory::Physical::free_page_low(physical);

        return Memory::Physical::free_page_high(physical);
 }

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---