memory.c

ADS环境下的类似linux内核的操作系统

/* MShowTec - www.mshowtec.com
** msLinux memory.c ver1.0
** 20051221 lmjx create [e-mail]
** 
*/

#define MSLINUX_MEMORY_C

#include "memory.h"

struct tag_Pool
{
	unsigned short memoryPool00 [ MAKE_MEMORY_POOL_SIZE( CLUSTER00_LEN, NB_CLUSTER00 ) ];
	unsigned short memoryPool01 [ MAKE_MEMORY_POOL_SIZE( CLUSTER01_LEN, NB_CLUSTER01 ) ];
	unsigned short memoryPool02 [ MAKE_MEMORY_POOL_SIZE( CLUSTER02_LEN, NB_CLUSTER02 ) ];
	unsigned short memoryPool03 [ MAKE_MEMORY_POOL_SIZE( CLUSTER03_LEN, NB_CLUSTER03 ) ];
	unsigned short memoryPool04 [ MAKE_MEMORY_POOL_SIZE( CLUSTER04_LEN, NB_CLUSTER04 ) ];
	unsigned short memoryPool05 [ MAKE_MEMORY_POOL_SIZE( CLUSTER05_LEN, NB_CLUSTER05 ) ];
	unsigned short memoryPool06 [ MAKE_MEMORY_POOL_SIZE( CLUSTER06_LEN, NB_CLUSTER06 ) ];
	unsigned short memoryPool07 [ MAKE_MEMORY_POOL_SIZE( CLUSTER07_LEN, NB_CLUSTER07 ) ];
	unsigned short memoryPool08 [ MAKE_MEMORY_POOL_SIZE( CLUSTER08_LEN, NB_CLUSTER08 ) ];
	
}pool={{0},{0},{0},{0},{0},{0},{0},{0},{0}};

struct tag_PoolDesc
{
	unsigned short clusterLen;
	unsigned short clusterNb;
	unsigned short *p_cluster;
	
}poolDesc[TOTAL_POLL_NB];

void mslinux_memory_pool_desc_init()
{
	int i;
	
	poolDesc[0].clusterLen = CLUSTER00_LEN;
	poolDesc[0].clusterNb  = NB_CLUSTER00;
	poolDesc[0].p_cluster  = pool.memoryPool00;
	for(i = 0;i <MAKE_MEMORY_POOL_SIZE(CLUSTER00_LEN,NB_CLUSTER00);i++)
		pool.memoryPool00[i] = 0x0000;	
	
	poolDesc[1].clusterLen = CLUSTER01_LEN;
	poolDesc[1].clusterNb  = NB_CLUSTER01;
	poolDesc[1].p_cluster  = pool.memoryPool01;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER01_LEN,NB_CLUSTER01);i++)
		pool.memoryPool01[i] = 0x0000;
			
	poolDesc[2].clusterLen = CLUSTER02_LEN;
	poolDesc[2].clusterNb  = NB_CLUSTER02;
	poolDesc[2].p_cluster  = pool.memoryPool02;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER02_LEN,NB_CLUSTER02);i++)
		pool.memoryPool02[i] = 0x0000;
	
	poolDesc[3].clusterLen = CLUSTER03_LEN;
	poolDesc[3].clusterNb  = NB_CLUSTER03;
	poolDesc[3].p_cluster  = pool.memoryPool03;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER03_LEN,NB_CLUSTER03);i++)
		pool.memoryPool03[i] = 0x0000;
	
	poolDesc[4].clusterLen = CLUSTER04_LEN;
	poolDesc[4].clusterNb  = NB_CLUSTER04;
	poolDesc[4].p_cluster  = pool.memoryPool04;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER04_LEN,NB_CLUSTER04);i++)
		pool.memoryPool04[i] = 0x0000;
	
	poolDesc[5].clusterLen = CLUSTER05_LEN;
	poolDesc[5].clusterNb  = NB_CLUSTER05;
	poolDesc[5].p_cluster  = pool.memoryPool05;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER05_LEN,NB_CLUSTER05);i++)
		pool.memoryPool05[i] = 0x0000;
	
	poolDesc[6].clusterLen = CLUSTER06_LEN;
	poolDesc[6].clusterNb  = NB_CLUSTER06;
	poolDesc[6].p_cluster  = pool.memoryPool06;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER06_LEN,NB_CLUSTER06);i++)
		pool.memoryPool06[i] = 0x0000;
	
	poolDesc[7].clusterLen = CLUSTER07_LEN;
	poolDesc[7].clusterNb  = NB_CLUSTER07;
	poolDesc[7].p_cluster  = pool.memoryPool07;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER07_LEN,NB_CLUSTER07);i++)
		pool.memoryPool07[i] = 0x0000;
	
	poolDesc[8].clusterLen = CLUSTER08_LEN;
	poolDesc[8].clusterNb  = NB_CLUSTER08;
	poolDesc[8].p_cluster  = pool.memoryPool08;
	for(i = 0;i < MAKE_MEMORY_POOL_SIZE(CLUSTER08_LEN,NB_CLUSTER08);i++)
		pool.memoryPool08[i] = 0x0000;
	
}

unsigned short mslinux_init_cluster(unsigned short poolId)
{
	int i,clusterLen;
	unsigned char *p = 0;
	
	if(poolId > TOTAL_POLL_NB)
		return 0xffff;
	
	clusterLen = poolDesc[poolId].clusterLen;
	p = (unsigned char *)(poolDesc[poolId].p_cluster);	
	for(i = 0;i <poolDesc[poolId].clusterNb;i++ ){	
		((MemCluster*)p)->checkFirst = 0x55aa;
		((MemCluster*)p)->checkLast  = 0xaa55;
		((MemCluster*)p)->usedFlag	 = 0x0000;
		((MemCluster*)p)->poolNumber = i|(poolId<<8);
		p += MAKE_POOL_CLUSTER_SIZE(clusterLen);
	}
	
	return 0x0000;
	
}

unsigned short ms_init_all_cluster()
{
	int i,ret;
	
	for(i = 0;i < TOTAL_POLL_NB;i++){
		ret = mslinux_init_cluster(i);
		if(ret)
			return ret;
	}
	
	return 0x0000;
	
}

unsigned short mslinux_get_total_pool_nb()
{
	return TOTAL_POLL_NB;
}

unsigned short mslinux_get_pool_len(unsigned short poolId)
{
	if(poolId >= TOTAL_POLL_NB)
		return 0xffff;
	else 
		return poolDesc[poolId].clusterLen;  
		
}

unsigned short mslinux_get_pool_nb(unsigned short poolId)
{
	if(poolId >= TOTAL_POLL_NB)
		return 0xffff;
	else 
		return poolDesc[poolId].clusterNb;  
		
}

void *mslinux_get_pool(unsigned short size)
{
	int i,j;
	unsigned short clusterLen;
	unsigned char *p = 0;
	
	for(i = 0; i< TOTAL_POLL_NB;i++){
		if(poolDesc[i].clusterLen >= size){
			p = (unsigned char *)(poolDesc[i].p_cluster);
			clusterLen = poolDesc[i].clusterLen;
			for(j = 0; j < poolDesc[i].clusterNb;j++){
				if((((MemCluster*)p)->checkFirst == 0x55aa)&&(((MemCluster*)p)->checkLast == 0xaa55)){
					if(((MemCluster*)p)->usedFlag == 0x0000){
						//find a free buffer
						((MemCluster*)p)->usedFlag = 0x0001;
						return (void*)(p+sizeof(MemCluster));
					}
				}else{
					// memory falt error!!!!!!
					printk("[malloc]:memory over follow size = %d!!\r\n",size);
					for(;;);
				}
				p += MAKE_POOL_CLUSTER_SIZE(clusterLen);
			}
		}
	}
	return 0;
}

void mslinux_free_pool(void *p_pool)
{	
	unsigned char *p = 0;

	//not in pool
	if(((long)p_pool > ((long)(&pool)+sizeof(pool))) ||((long)p_pool < ((long)(&pool))))
		return;
	
	p = (unsigned char*)p_pool - sizeof(MemCluster);
	
	if((((MemCluster*)p)->checkFirst == 0x55aa)&&(((MemCluster*)p)->checkLast == 0xaa55)){
		((MemCluster*)p)->usedFlag = 0x0000;
	}else{
		// memory falt error!!!!!!
		printk("[free]:memory over follow!!\r\n");
		for(;;);
	}
	
}

void mem_init()
{
	mslinux_memory_pool_desc_init();
	ms_init_all_cluster();
}