void* kmalloc(uint32_t len) {
len += sizeof(kheader_t);
kheader_t *cur_header = kheap_first, *prev_header = 0;
while (cur_header) {
if (cur_header->allocated == 0 && cur_header->length >= len) {
split_chunk(cur_header, len);
cur_header->allocated = 1;
return (void*) ((uint32_t) cur_header + sizeof(kheader_t));
}
prev_header = cur_header;
cur_header = cur_header->next;
}
uint32_t chunk_start;
if (prev_header)
chunk_start = (uint32_t) prev_header + prev_header->length;
else {
chunk_start = KHEAP_START;
kheap_first = (kheader_t *) chunk_start;
}
alloc_chunk(chunk_start, len);
cur_header = (kheader_t *) chunk_start;
cur_header->prev = prev_header;
cur_header->next = 0;
cur_header->allocated = 1;
cur_header->length = len;
prev_header->next = cur_header;
return (void*) (chunk_start + sizeof(kheader_t));
}
//还是理解一下内核中的堆栈的到底是怎么一个概念，
void *kmalloc(uint32 len)
{
//申请的内存必须加上头指针，用于管理内存的空间
len += sizeof(heap_t);
heap_t * cur_head = heap_first;
heap_t * prev_head = 0;
//第一次运行的时候为0,然后运行的时候，先判断已经使用过的内存中
//有没有能用的，如果有能用的，则不用申请其他的内存使用
while (cur_head) {
if (cur_head->allocate == 0 && cur_head->length > len) {
//切分len的长度的内存出来
split_chunk(cur_head, len);
//将这个内存头指针标示为1,标示已经使用
cur_head->allocate = 1;
/*
*这个目前不是很理解
*/
return (void *) ((uint32)cur_head + sizeof(heap_t));
}
prev_head = cur_head;
cur_head = cur_head->next;
}
uint32 chunk_start;
//第一次执行，会执行else后面的代码，然后第二次初始化后执行正确的
if (prev_head) {
chunk_start = (uint32)prev_head + prev_head->length;
} else {
chunk_start = HEAP_START;
heap_first = (heap_t *)chunk_start;
}
//就是把这个线性地址和物理地址形成映射
alloc_chunk(chunk_start, len);
//描述找个内存块的相关信息
cur_head = (heap_t *) chunk_start;
//连接到上一个已经藐视内存的结构体
cur_head->prev = prev_head;
cur_head->next = 0;
cur_head->allocate = 1;
cur_head->length = len;
//将两个用过的内存块链接在一起
if (prev_head) {
prev_head->next = cur_head;
}
//申请的空间头部有heap_t这个结构体，只是描述这个内存块的信息
//所以返回的地址必须是除去这个结构体的，由于内存向上增加
return (void *)(chunk_start + sizeof(heap_t));
}
void *kmalloc(uint32_t len)
{
// 所有申请的内存长度加上管理头的长度
// 因为在内存申请和释放的时候要通过该结构去管理
len += sizeof(header_t);
header_t *cur_header = heap_first;
header_t *prev_header = 0;
while (cur_header) {
// 如果当前内存块没有被申请过而且长度大于待申请的块
if (cur_header->allocated == 0 && cur_header->length >= len) {
// 按照当前长度切割内存
split_chunk(cur_header, len);
cur_header->allocated = 1;
// 返回的时候必须将指针挪到管理结构之后
return (void *)((uint32_t)cur_header + sizeof(header_t));
}
// 逐次推移指针
prev_header = cur_header;
cur_header = cur_header->next;
}
uint32_t chunk_start;
// 第一次执行该函数则初始化内存块起始位置
// 之后根据当前指针加上申请的长度即可
if (prev_header) {
chunk_start = (uint32_t)prev_header + prev_header->length;
} else {
chunk_start = HEAP_START;
heap_first = (header_t *)chunk_start;
}
// 检查是否需要申请内存页
alloc_chunk(chunk_start, len);
cur_header = (header_t *)chunk_start;
cur_header->prev = prev_header;
cur_header->next = 0;
cur_header->allocated = 1;
cur_header->length = len;
if (prev_header) {
prev_header->next = cur_header;
}
return (void*)(chunk_start + sizeof(header_t));
}
static void *sub_get_bestfit(t_chunk **b_fit, unsigned long total_size,
t_chunk **flist, t_chunk **alist)
{
t_chunk *tmp_sbrk;
(*b_fit)->magic = M_ALLOC;
if ((*b_fit)->size > total_size + HEADER_SIZE
&& (tmp_sbrk = sbrk(0)) != (void *)FAIL
&& (void *)(*b_fit) + total_size <= (void *)tmp_sbrk)
{
split_chunk(*b_fit, total_size);
put_in_list(&flist[MAPSIZE - 1], (*b_fit)->next);
(*b_fit)->next = NULL;
}
put_in_list(&(alist[INDEX((*b_fit)->size)]), *b_fit);
return ((t_chunk *)(*b_fit) + 1);
}
void *kmalloc(uint32_t len)
{
heap_header_t *curr, *prev;
uint32_t chunk_start;
len += sizeof(heap_header_t); // include sizeof(heap_header_t)
curr = heap_frist;
prev = 0;
while (curr) {
if (curr->allocated == 0 && curr->length >= len) {
split_chunk(curr, len);
curr->allocated = 1;
return (void *)((uint32_t)curr + sizeof(heap_header_t));
}
prev = curr;
curr = curr->next;
}
if (prev) {
chunk_start = (uint32_t)prev + prev->length;
} else {
chunk_start = HEAP_START_ADDR;
heap_frist = (heap_header_t *)chunk_start;
}
alloc_chunk(chunk_start, len);
curr = (heap_header_t *)chunk_start;
curr->prev = prev;
curr->next = 0;
curr->allocated = 1;
curr->length = len;
if (prev) {
prev->next = curr;
}
return (void *)(chunk_start + sizeof(heap_header_t));
}
static void
occupy_chunk( SurfaceManager *manager, Chunk *chunk, SurfaceBuffer *buffer, int length )
{
D_MAGIC_ASSERT( manager, SurfaceManager );
D_MAGIC_ASSERT( chunk, _Chunk_ );
if (buffer->policy == CSP_VIDEOONLY)
manager->available -= length;
chunk = split_chunk( chunk, length );
D_DEBUG_AT( Core_SM, "Allocating %d bytes at offset %d.\n", chunk->length, chunk->offset );
buffer->video.health = CSH_RESTORE;
buffer->video.offset = chunk->offset;
buffer->video.chunk = chunk;
chunk->buffer = buffer;
manager->min_toleration++;
}
void *kmalloc(uint32_t len){
len += sizeof(header_t);
header_t *cur_header = heap_first;
header_t *prev_header = 0;
while(cur_header){
if(cur_header->allocated == 0 && cur_header->length >= len){
split_chunk(cur_header, len);
cur_header->allocated = 1;
return (void *)((uint32_t)cur_header + sizeof(header_t));
}
prev_header = cur_header;
cur_header = cur_header->next;
}
uint32_t chunk_start;
if(prev_header){
chunk_start = (uint32_t)prev_header + prev_header->length;
}
else{
chunk_start = HEAP_START;
heap_first = (header_t *)chunk_start;
}
//check if need RAM
alloc_chunk(chunk_start, len);
cur_header = (header_t *)chunk_start;
cur_header->prev = prev_header;
cur_header->next = 0;
cur_header->allocated = 1;
cur_header->length = len;
if(prev_header)
prev_header->next = cur_header;
return (void*)(chunk_start + sizeof(header_t));
}
