path: root/kernel/mem.c

#define FOOLOS_MODULE_NAME "mem"

#include "config.h"
#include "lib/int/stdint.h"
#include "lib/logger/log.h"	// logger facilities

//! 8 blocks per byte
#define PMMNGR_BLOCKS_PER_BYTE 8
 
//! block size (4k)
#define PMMNGR_BLOCK_SIZE	4096
 
//! block alignment ??? TODO: what is this!?
#define PMMNGR_BLOCK_ALIGN	PMMNGR_BLOCK_SIZE

//memory map bit array. Each bit represents a 4KB memory block
static uint32_t *_mmngr_memory_map;

static uint32_t mem_free_blocks;
static uint32_t mem_array_size;

// bit funcs!
void mmap_set(int bit) 
{
      _mmngr_memory_map[bit / 32] |= (1 << (bit % 32));
}

void mmap_unset(int bit)
{
      _mmngr_memory_map[bit / 32] &= ~ (1 << (bit % 32));
}

int  mmap_test(int bit)
{
     return _mmngr_memory_map[bit / 32] &  (1 << (bit % 32));
}

void pmmngr_init () 
{
    // By default, all of memory is in use
    for(int i=0;i<mem_array_size;i++)
    {
	_mmngr_memory_map[i]=0xffffffff;
    }
}

//find the first free bit
int mmap_first_free () 
{
    for (int i=0; i< mem_array_size ; i++)
	if (_mmngr_memory_map[i] != 0xffffffff)
	    for (int j=0; j<32; j++) 
	    {		
		if(!mmap_test(32*i+j))return 32*i+j;
	    }
 
    return -1;
}

//find the first free consecutive x bits
int mmap_first_free_s (uint32_t x) 
{
    int found=0;

    for (int i=0; i< mem_array_size; i++)
	if (_mmngr_memory_map[i] != 0xffffffff)
	    for (int j=0; j<32; j++)
	    {
		if(!mmap_test(32*i+j))found++;
		else found=0;
		if(found==x)return 32*i+j;
	    }

    return -1;
}

void pmmngr_init_region (uint32_t  base, uint32_t size)
{
    uint32_t align = base / PMMNGR_BLOCK_SIZE;
    uint32_t blocks = size / PMMNGR_BLOCK_SIZE;

    for (; blocks>0; blocks--) 
    {
	mmap_unset (align++);
	mem_free_blocks++;
    }
}

void pmmngr_deinit_region (uint32_t  base, uint32_t size)
{
    uint32_t align = base / PMMNGR_BLOCK_SIZE;
    uint32_t blocks = size / PMMNGR_BLOCK_SIZE;

    for (; blocks>0; blocks--) 
    {
	mmap_set (align++);
	mem_free_blocks--;
    }

}

void* pmmngr_alloc_block () 
{
    int frame = mmap_first_free ();

    if (frame == -1)
    {
	panic(FOOLOS_MODULE_NAME,"OUT OF MEMORY (alloc_block)");
	return 0;	//out of memory
    }

    mmap_set (frame);
    mem_free_blocks--;

    uint32_t addr = frame * PMMNGR_BLOCK_SIZE;

    return (void*)addr;
}

void* pmmngr_alloc_blocks (uint32_t size) 
{

    int frame = mmap_first_free_s (size);

    if (frame == -1)
    {
	panic(FOOLOS_MODULE_NAME,"OUT OF MEMORY (alloc_blocks)");
	return 0;	//out of memory
    }

    for (int i=0; i<size; i++)
    {
	mmap_set (frame+i);
	mem_free_blocks--;
    }

    uint32_t addr = frame * PMMNGR_BLOCK_SIZE;

    return (void*)addr;
}

void pmmngr_free_block (void* p) 
{
    uint32_t addr = (uint32_t*)p;
    int frame = addr / PMMNGR_BLOCK_SIZE;
 
    if(mmap_test(frame))
    {
	mmap_unset (frame);
	mem_free_blocks++;
    }
}

void mem_init(uint16_t *memmap,uint16_t entries)
{

    // init free blocks counter
    mem_free_blocks=0;

    // count available mem
    uint32_t total_mem=0, highest_end=0, high_end_low=0,last_end=0;

    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"the memory map contains %d entries.",entries);

    // preserve pointer
    uint16_t save=memmap;

    //print memory map and calc blocks.
    for(int i=0;i<entries;i++)
    {
	uint32_t low_end=(((uint32_t)memmap[1])<<16)+memmap[0];
	uint32_t high_end=(((uint32_t)memmap[1])<<16)+memmap[0]-1
	 		    +(((uint32_t)memmap[5])<<16)+memmap[4];

	#ifdef MEM_PRINT_MEMORYMAP
	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"type: %02d / range:  0x%08x - 0x%08x",
		memmap[8],low_end,high_end);
	#endif

	if(memmap[8]==1||memmap[8]==3)
	{
	    total_mem+=memmap[4]+(memmap[5]<<16); 

	    if(high_end>highest_end)
	    {
		highest_end=high_end;
		high_end_low=last_end;
	    }
	}
	else
	{
	    last_end=high_end+1;
	}

	memmap+=12;
	
    }
    // restore pointer
    memmap=save;

    int blocks=highest_end/4096+1;
    mem_array_size=blocks/32+1;


    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Highest end area: 0x%08X - 0x%08X",high_end_low,highest_end);
    if(highest_end-high_end_low<mem_array_size*4)
    {
	panic(FOOLOS_MODULE_NAME,"not enough space at high end :( sorry.");
    }

    _mmngr_memory_map=highest_end-mem_array_size*4;
    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Initializing bitmap for 0x%X blocks at 0x%08X",blocks,_mmngr_memory_map);

    pmmngr_init ();


    for(int i=0;i<entries;i++)
    {
	if(memmap[8]==1||memmap[8]==3)
	{
	    pmmngr_init_region(memmap[0]+(memmap[1]<<16),memmap[4]+((memmap[5])<<16));
	}
	memmap+=12;
    }
    
    // here is somewhere our kernel stuff ;) // TODO!! better.
    pmmngr_deinit_region(0x0,0x150000);

    // and here is the memory map that we JUST created!
    pmmngr_deinit_region(_mmngr_memory_map,mem_array_size*4);
    

    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Usable Mem: %d (0x%X) bytes. (~%d MB)",total_mem,total_mem,total_mem/1024/1024);
    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Currently Free 4K blocks: %d blocks.",mem_free_blocks);

}

// analytics
void mmap_show_free ()
{

    int last_pos=0; 
    uint32_t last=_mmngr_memory_map[0];

    for (int i=1; i< mem_array_size ; i++)
    {
	if (_mmngr_memory_map[i] != last||i==mem_array_size-1)
	{

	    if(last==0)
	    {
		log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%d -%d free",last_pos*32,i*32);
	    }
	    else if(last==0xffffffff)
	    {
		log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%d -%d full",last_pos*32,i*32);
	    }
	    else
	    {
		log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%d -%d some free",last_pos*32,i*32);
	    }

	   last_pos=i;
	   last=_mmngr_memory_map[i];


	}
    }

}