从零手写操作系统之RVOS内存管理模块简单实现-02

ld -verbose

ld –T link.script

os.elf: ${OBJS}
	${CC} ${CFLAGS} -Ttext=0x80000000 -o os.elf $^
	${OBJCOPY} -O binary os.elf os.bin

SECTIONS
{
  .text :
  {
    *(.text)
  }
  
  .data :
  {
    *(.data)
  }
  
  .bss :
  {
    *(.bss)
  }
  
  /* 定义一个名为 _custom_symbol 的符号，并将其赋值为 42 */
  PROVIDE(_custom_symbol = 42);
}


#include <stdio.h>
extern int _custom_symbol;
int main() {
    printf("The value of _custom_symbol is: %d\n", _custom_symbol);
    return 0;
}

SECTIONS
{
  /* ...其他部分... */

  /* 定义一个名为 _asm_var 的符号，并将其赋值为 100 */
  PROVIDE(_asm_var = 100);
}

.section .data
.global asm_var
asm_var:
  .word _asm_var


#include <stdio.h>
extern int asm_var;
int main() {
    printf("The value of asm_var is: %d\n", asm_var);
    return 0;
}

/*
 * Following global vars are defined in mem.S
 */
extern uint32_t TEXT_START;
extern uint32_t TEXT_END;
extern uint32_t DATA_START;
extern uint32_t DATA_END;
extern uint32_t RODATA_START;
extern uint32_t RODATA_END;
extern uint32_t BSS_START;
extern uint32_t BSS_END;
extern uint32_t HEAP_START;
extern uint32_t HEAP_SIZE;

/*
 * _alloc_start points to the actual start address of heap pool
 * _alloc_end points to the actual end address of heap pool
 * _num_pages holds the actual max number of pages we can allocate.
 */
static uint32_t _alloc_start = 0;
static uint32_t _alloc_end = 0;
static uint32_t _num_pages = 0;

/*
 * Page Descriptor 
 * flags:
 * - bit 0: flag if this page is taken(allocated)
 * - bit 1: flag if this page is the last page of the memory block allocated
 */
struct Page {
	uint8_t flags;
};

void page_init()
{
	/* 
	 * We reserved 8 Page (8 x 4096) to hold the Page structures.
	 * It should be enough to manage at most 128 MB (8 x 4096 x 4096) 
	 */
	 //_num_pages是实例用户可用的物理页数量
	_num_pages = (HEAP_SIZE / PAGE_SIZE) - 8;
	printf("HEAP_START = %x, HEAP_SIZE = %x, num of pages = %d\n", HEAP_START, HEAP_SIZE, _num_pages);
	
	struct Page *page = (struct Page *)HEAP_START;
	//初始化索引记录---每条索引记录对应一个用户可用物理页面
	for (int i = 0; i < _num_pages; i++) {
		_clear(page);
		page++;	
	}
    //物理页对齐4KB---将给定的地址按页面边界（4KB）对齐，确保地址位于所在页面的起始位置
	_alloc_start = _align_page(HEAP_START + 8 * PAGE_SIZE);
	//堆内存最大范围
	_alloc_end = _alloc_start + (PAGE_SIZE * _num_pages);

	printf("TEXT:   0x%x -> 0x%x\n", TEXT_START, TEXT_END);
	printf("RODATA: 0x%x -> 0x%x\n", RODATA_START, RODATA_END);
	printf("DATA:   0x%x -> 0x%x\n", DATA_START, DATA_END);
	printf("BSS:    0x%x -> 0x%x\n", BSS_START, BSS_END);
	printf("HEAP:   0x%x -> 0x%x\n", _alloc_start, _alloc_end);
}

//初始化过程就是将标志位清空
static inline void _clear(struct Page *page){
	page->flags = 0;
}

/*
 * Allocate a memory block which is composed of contiguous physical pages
 * - npages: the number of PAGE_SIZE pages to allocate
 */
void *page_alloc(int npages)
{
	/* Note we are searching the page descriptor bitmaps. */
	int found = 0;
	//遍历索引数组
	struct Page *page_i = (struct Page *)HEAP_START;
	//_num_pages表示堆内存页面总数(用户可用堆内存--上面page_init函数中初始化过了)
	for (int i = 0; i <= (_num_pages - npages); i++) {
		//判断当前页面是否空闲
		if (_is_free(page_i)) {
			found = 1;
			/* 
			 * meet a free page, continue to check if following
			 * (npages - 1) pages are also unallocated.
			 */
			// 检查接下来的npages-1个物理页面是否同样空闲
			struct Page *page_j = page_i + 1;
			for (int j = i + 1; j < (i + npages); j++) {
			    //只要有一个物理页面不空闲,说明这块连续内存空间大小不满足我们的要求
				if (!_is_free(page_j)) {
				   //重新设置found=0
					found = 0;
					break;
				}
				page_j++;
			}
			/*
			 * get a memory block which is good enough for us,
			 * take housekeeping, then return the actual start
			 * address of the first page of this memory block
			 */
			//找到了满足要求的连续内存空间
			if (found) {
				//设置好相关物理页面对应的索引记录标志位为占用状态
				struct Page *page_k = page_i;
				for (int k = i; k < (i + npages); k++) {
					_set_flag(page_k, PAGE_TAKEN);
					page_k++;
				}
				//设置连续分配的页面中最后一个页面的flags标志位第1位为1,表示为当前分配中的最后一个物理页面
				page_k--;
				_set_flag(page_k, PAGE_LAST);
				//返回分配内存的起始地址
				return (void *)(_alloc_start + i * PAGE_SIZE);
			}
		}
		page_i++;
	}
	return NULL;
}

static inline int _is_free(struct Page *page)
{
	if (page->flags & PAGE_TAKEN) {
		return 0;
	} else {
		return 1;
	}
}

static inline void _set_flag(struct Page *page, uint8_t flags)
{
	page->flags |= flags;
}

/*
 * Free the memory block
 * - p: start address of the memory block
 */
void page_free(void *p)
{
	/*
	 * Assert (TBD) if p is invalid
	 */
	//内存地址不合法或者超出的堆内存最大限制,直接返回
	if (!p || (uint32_t)p >= _alloc_end) {
		return;
	}
	/* get the first page descriptor of this memory block */
	struct Page *page = (struct Page *)HEAP_START;
	//定位对应的索引记录下标
	page += ((uint32_t)p - _alloc_start)/ PAGE_SIZE;
	/* loop and clear all the page descriptors of the memory block */
	//将对应page被占用的标记清空,同时如果是连续分配的最后一个页面,清空其PAGE_LAST标记
	while (!_is_free(page)) {
		if (_is_last(page)) {
			_clear(page);
			break;
		} else {
			_clear(page);
			page++;;
		}
	}
}

static inline int _is_last(struct Page *page)
{
	if (page->flags & PAGE_LAST) {
		return 1;
	} else {
		return 0;
	}
}

#include "os.h"

/*
 * Following functions SHOULD be called ONLY ONE time here,
 * so just declared here ONCE and NOT included in file os.h.
 */
extern void uart_init(void);
extern void page_init(void);

void start_kernel(void)
{
	uart_init();
	uart_puts("Hello, RVOS!\n");

	page_init();
    //页面分配测试
	page_test();
	while (1) {}; // stop here!
}


void page_test()
{
	void *p = page_alloc(2);
	printf("p = 0x%x\n", p);
	//page_free(p);

	void *p2 = page_alloc(7);
	printf("p2 = 0x%x\n", p2);
	page_free(p2);

	void *p3 = page_alloc(4);
	printf("p3 = 0x%x\n", p3);
}