406 lines
8.7 KiB
C
406 lines
8.7 KiB
C
#include "type.h"
|
||
#include "const.h"
|
||
#include "protect.h"
|
||
#include "string.h"
|
||
#include "proc.h"
|
||
#include "global.h"
|
||
#include "proto.h"
|
||
#include "memman.h"
|
||
#include "stdio.h"
|
||
|
||
u32 MemInfo[256] = {0}; //存放FMIBuff后1k内容
|
||
struct MEMMAN s_memman;
|
||
struct MEMMAN *memman = &s_memman;//(struct MEMMAN *) MEMMAN_ADDR;
|
||
|
||
|
||
void memman_init(struct MEMMAN *man);
|
||
u32 memman_alloc(struct MEMMAN *man,u32 size);
|
||
u32 memman_kalloc(struct MEMMAN *man,u32 size);
|
||
u32 memman_alloc_4k(struct MEMMAN *man);
|
||
u32 memman_kalloc_4k(struct MEMMAN *man);
|
||
u32 memman_free(struct MEMMAN *man, u32 addr, u32 size);
|
||
void disp_free();
|
||
u32 memman_total(struct MEMMAN *man);
|
||
|
||
void init() //初始化
|
||
{
|
||
u32 memstart = MEMSTART; //4M 开始初始化
|
||
u32 i,j;
|
||
|
||
memcpy(MemInfo,(u32 *)FMIBuff,1024); //复制内存
|
||
|
||
memman_init(memman); //初始化memman中frees,maxfrees,lostsize,losts
|
||
|
||
for(i = 1; i <= MemInfo[0]; i++)
|
||
{
|
||
if(MemInfo[i] < memstart)continue; //4M 之后开始free
|
||
memman_free(memman,memstart,MemInfo[i] - memstart); //free每一段可用内存
|
||
memstart = MemInfo[i] + 0x1000; //memtest_sub(start,end)中每4KB检测一次
|
||
}
|
||
|
||
for(i = 0; i < memman->frees; i++)
|
||
{//6M处分开，4～6M为kmalloc_4k使用，6～8M为kmalloc使用
|
||
if((memman->free[i].addr <= KWALL)&&(memman->free[i].addr + memman->free[i].size > KWALL)){
|
||
if(memman->free[i].addr == KWALL)break;
|
||
else{
|
||
|
||
for(j = memman->frees; j>i+1; j--)
|
||
{ //i之后向后一位
|
||
memman->free[j] = memman->free[j-1];
|
||
}
|
||
memman->frees++;
|
||
if(memman->maxfrees < memman->frees){ //更新man->maxfrees
|
||
memman->maxfrees = memman->frees;
|
||
}
|
||
memman->free[i+1].addr = KWALL;
|
||
memman->free[i+1].size = memman->free[i].addr + memman->free[i].size - KWALL;
|
||
memman->free[i].size = KWALL - 0x1000 - memman->free[i].addr;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
for(i = 0; i < memman->frees; i++)
|
||
{//8M处分开，4～8M为kmalloc使用，8～32M为malloc使用
|
||
if((memman->free[i].addr <= WALL)&&(memman->free[i].addr + memman->free[i].size > WALL)){
|
||
if(memman->free[i].addr == WALL)break;
|
||
else{
|
||
|
||
for(j = memman->frees; j>i+1; j--)
|
||
{ //i之后向后一位
|
||
memman->free[j] = memman->free[j-1];
|
||
}
|
||
memman->frees++;
|
||
if(memman->maxfrees < memman->frees){ //更新man->maxfrees
|
||
memman->maxfrees = memman->frees;
|
||
}
|
||
memman->free[i+1].addr = WALL;
|
||
memman->free[i+1].size = memman->free[i].addr + memman->free[i].size - WALL;
|
||
memman->free[i].size = WALL - 0x1000 - memman->free[i].addr;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
for(i = 0; i < memman->frees; i++)
|
||
{//16M处分开，8～16M为malloc使用，16～32M为malloc_4k使用
|
||
if((memman->free[i].addr <= UWALL)&&(memman->free[i].addr + memman->free[i].size > UWALL)){
|
||
if(memman->free[i].addr == UWALL)break;
|
||
else{
|
||
|
||
for(j = memman->frees; j>i+1; j--)
|
||
{ //i之后向后一位
|
||
memman->free[j] = memman->free[j-1];
|
||
}
|
||
memman->frees++;
|
||
if(memman->maxfrees < memman->frees){ //更新man->maxfrees
|
||
memman->maxfrees = memman->frees;
|
||
}
|
||
memman->free[i+1].addr = UWALL;
|
||
memman->free[i+1].size = memman->free[i].addr + memman->free[i].size - UWALL;
|
||
memman->free[i].size = UWALL - 0x1000 - memman->free[i].addr;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//modified by xw, 18/6/18
|
||
//显示初始总容量
|
||
kprintf("Memory Available:%d\n", memman_total(memman));
|
||
//~xw
|
||
|
||
return;
|
||
|
||
} //于kernel_main()中调用，进行初始化
|
||
|
||
void memman_init(struct MEMMAN *man)
|
||
{ //memman基本信息初始化
|
||
man->frees = 0;
|
||
man->maxfrees = 0;
|
||
man->lostsize = 0;
|
||
man->losts = 0;
|
||
return;
|
||
}
|
||
|
||
u32 memman_alloc(struct MEMMAN *man,u32 size)
|
||
{ //分配
|
||
u32 i,a;
|
||
for(i=0; i<man->frees; i++)
|
||
{
|
||
if((man->free[i].addr >= WALL)&&(man->free[i].addr + size < UWALL)){ //8M到16M
|
||
if(man->free[i].size >= size){
|
||
a = man->free[i].addr;
|
||
man->free[i].addr += size;
|
||
man->free[i].size -= size;
|
||
if(man->free[i].size == 0){
|
||
man->frees--;
|
||
for(; i<man->frees; i++)
|
||
{
|
||
man->free[i] = man->free[i+1];
|
||
}
|
||
}
|
||
return a;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
u32 memman_kalloc(struct MEMMAN *man,u32 size)
|
||
{ //分配
|
||
u32 i,a;
|
||
for(i=0; i<man->frees; i++)
|
||
{
|
||
if((man->free[i].addr >= KWALL)&&(man->free[i].addr + size < WALL)){ //4M到8M
|
||
if(man->free[i].size >= size){
|
||
a = man->free[i].addr;
|
||
man->free[i].addr += size;
|
||
man->free[i].size -= size;
|
||
if(man->free[i].size == 0){
|
||
man->frees--;
|
||
for(; i<man->frees; i++)
|
||
{
|
||
man->free[i] = man->free[i+1];
|
||
}
|
||
}
|
||
return a;
|
||
}
|
||
}
|
||
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
u32 memman_alloc_4k(struct MEMMAN *man)
|
||
{ //分配
|
||
u32 i,a;
|
||
u32 size = 0x1000;
|
||
for(i=0; i<man->frees; i++)
|
||
{
|
||
if((man->free[i].addr >= UWALL)&&(man->free[i].addr + size < MEMEND)){ //16M到32M
|
||
if(man->free[i].size >= size){
|
||
a = man->free[i].addr;
|
||
man->free[i].addr += size;
|
||
man->free[i].size -= size;
|
||
if(man->free[i].size == 0){
|
||
man->frees--;
|
||
for(; i<man->frees; i++)
|
||
{
|
||
man->free[i] = man->free[i+1];
|
||
}
|
||
}
|
||
return a;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
u32 memman_kalloc_4k(struct MEMMAN *man)
|
||
{ //分配
|
||
u32 i,a;
|
||
u32 size = 0x1000;
|
||
for(i=0; i<man->frees; i++)
|
||
{
|
||
if((man->free[i].addr >= MEMSTART)&&(man->free[i].addr + size < KWALL)){ //4M到6M
|
||
if(man->free[i].size >= size){
|
||
a = man->free[i].addr;
|
||
man->free[i].addr += size;
|
||
man->free[i].size -= size;
|
||
if(man->free[i].size == 0){
|
||
man->frees--;
|
||
for(; i<man->frees; i++)
|
||
{
|
||
man->free[i] = man->free[i+1];
|
||
}
|
||
}
|
||
return a;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
u32 memman_free(struct MEMMAN *man, u32 addr, u32 size)
|
||
{ //释放
|
||
int i,j;
|
||
|
||
if(size == 0)return 0; //初始化时，防止有连续坏块
|
||
|
||
for(i=0; i<man->frees; i++)
|
||
{
|
||
if(man->free[i].addr > addr){
|
||
break;
|
||
}
|
||
} //man->free[i-1].addr < addr <man->free[i].addr
|
||
|
||
if(i > 0){ //前面有可分配内存
|
||
if(man->free[i-1].addr + man->free[i-1].size == addr){ //与前面相邻
|
||
man->free[i-1].size += size;
|
||
if(i < man->frees){ //后面有可分配内存
|
||
if(addr + size == man->free[i].addr){ //同时与后面相邻
|
||
man->free[i-1].size += man->free[i].size;
|
||
man->frees--;
|
||
for(; i<man->frees; i++)
|
||
{
|
||
man->free[i] = man->free[i+1]; //结构体赋值，i之后向前一位
|
||
}
|
||
}
|
||
}
|
||
return 0;
|
||
} //与前面不相邻
|
||
} //前面无可分配内存
|
||
|
||
if(i < man->frees){ //后面有可分配内存
|
||
if(addr + size == man->free[i].addr){ //与后面相邻
|
||
man->free[i].addr = addr;
|
||
man->free[i].size += size;
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
if(man->frees < MEMMAN_FREES){ //数组未满
|
||
for(j = man->frees; j>i; j--)
|
||
{ //i之后向后一位
|
||
man->free[j] = man->free[j-1];
|
||
}
|
||
man->frees++;
|
||
if(man->maxfrees < man->frees){ //更新man->maxfrees
|
||
man->maxfrees = man->frees;
|
||
}
|
||
man->free[i].addr = addr; //插入
|
||
man->free[i].size = size;
|
||
return 0;
|
||
}
|
||
|
||
man->losts++; //free失败
|
||
man->lostsize += size;
|
||
return -1;
|
||
}
|
||
|
||
u32 memman_free_4k(struct MEMMAN *man, u32 addr)
|
||
{
|
||
return memman_free(man, addr, 0x1000);
|
||
}
|
||
|
||
|
||
|
||
u32 do_malloc(u32 size)
|
||
{
|
||
return memman_alloc(memman,size);
|
||
}
|
||
|
||
u32 do_kmalloc(u32 size)
|
||
{
|
||
return memman_kalloc(memman,size);
|
||
}
|
||
|
||
u32 do_malloc_4k()
|
||
{
|
||
return memman_alloc_4k(memman);
|
||
}
|
||
|
||
u32 do_kmalloc_4k()
|
||
{
|
||
return memman_kalloc_4k(memman);
|
||
}
|
||
|
||
u32 do_free(u32 addr,u32 size)
|
||
{
|
||
return memman_free(memman,addr,size);
|
||
}
|
||
|
||
u32 do_free_4k(u32 addr)
|
||
{
|
||
return memman_free_4k(memman,addr);
|
||
}
|
||
|
||
void disp_free()
|
||
{ //打印空闲内存块信息
|
||
for(int i = 0; i < memman->frees; i++)
|
||
kprintf("0x%x#0x%x###", memman->free[i].addr, memman->free[i].size);
|
||
}
|
||
|
||
u32 memman_total(struct MEMMAN *man)
|
||
{ //free总容量
|
||
u32 i,t=0;
|
||
for(i=0; i<man->frees; i++){
|
||
t += man->free[i].size;
|
||
}
|
||
return t;
|
||
}
|
||
|
||
void memman_test()
|
||
{ //测试
|
||
u32 *p1 = 0;
|
||
u32 *p2 = 0;
|
||
u32 *p3 = 0;
|
||
u32 *p4 = 0;
|
||
u32 *p = 0;
|
||
|
||
p1 = (u32 *)do_malloc(4);
|
||
if(-1 != (u32)p1){ //打印p1，当前空闲内存信息，p1所指内存的内容
|
||
disp_str("START");
|
||
disp_int((u32)p1);
|
||
//disp_free();
|
||
*p1 = TEST;
|
||
disp_int(*p1);
|
||
disp_str("END");
|
||
}
|
||
|
||
p2 = (u32 *)do_kmalloc(4);
|
||
if(-1 != (u32)p2){
|
||
disp_str("START");
|
||
disp_int((u32)p2);
|
||
//disp_free();
|
||
*p2 = TEST;
|
||
disp_int(*p2);
|
||
disp_str("END");
|
||
}
|
||
|
||
do_free((u32)p1,4);
|
||
do_free((u32)p2,4);
|
||
|
||
p3 = (u32 *)do_malloc_4k();
|
||
if(-1 != (u32)p3){
|
||
disp_str("START");
|
||
disp_int((u32)p3);
|
||
//disp_free();
|
||
*p3 = TEST;
|
||
disp_int(*p3);
|
||
p = p3 + 2044;
|
||
*p = 0x22334455;
|
||
disp_int(*p);
|
||
p += 2048;
|
||
*p = 0x33445566;
|
||
disp_int(*p);
|
||
disp_str("END");
|
||
}
|
||
|
||
p4 = (u32 *)do_kmalloc_4k(4);
|
||
if(-1 != (u32)p4){
|
||
disp_str("START");
|
||
disp_int((u32)p4);
|
||
//disp_free();
|
||
*p4 = TEST;
|
||
disp_int(*p4);
|
||
p = p4 + 2044;
|
||
*p = 0x22334455;
|
||
disp_int(*p);
|
||
p += 2048;
|
||
*p = 0x33445566;
|
||
disp_int(*p);
|
||
disp_str("END");
|
||
}
|
||
|
||
do_free_4k((u32)p3);
|
||
do_free_4k((u32)p4);
|
||
|
||
disp_str("START");
|
||
disp_free();
|
||
disp_str("END");
|
||
|
||
return;
|
||
}
|
||
|