105 lines
3.2 KiB
C
105 lines
3.2 KiB
C
#include <list.h>
|
|
#include <mm.h>
|
|
#include <print.h>
|
|
|
|
struct dlist_node mm_free_page_list;
|
|
|
|
void mm_init() {
|
|
init_list(&mm_free_page_list);
|
|
}
|
|
|
|
//presupposes mm_free_page_list is a properly initialized list
|
|
void insert_page(struct page *p) {
|
|
if (list_empty(&mm_free_page_list) || p->address < container(mm_free_page_list.next, struct page, list)->address) {
|
|
insert_after(&mm_free_page_list, &p->list);
|
|
} else if (p->address > container(mm_free_page_list.prev, struct page, list)->address) {
|
|
insert_before(&mm_free_page_list, &p->list);
|
|
} else {
|
|
struct page *it;
|
|
for_each_list(it, &mm_free_page_list, struct page, list) {
|
|
if (p->address < it->address) {
|
|
insert_before(&it->list, &p->list);
|
|
return;
|
|
}
|
|
}
|
|
print("Error: failed to insert page\n");
|
|
}
|
|
}
|
|
|
|
void mm_add_free_region(void *start, void *end) {
|
|
unsigned int num_pages, usable_pages;
|
|
struct page *p;
|
|
void *page;
|
|
|
|
//make sure both start and end address are aligned to the size of a page
|
|
if ((unsigned int)start % MM_PAGE_SIZE != 0)
|
|
start = (char*)start + (MM_PAGE_SIZE - ((unsigned int)start % MM_PAGE_SIZE));
|
|
if (((unsigned int)end + 1) % MM_PAGE_SIZE != 0)
|
|
end = (char*)end - ((unsigned int)end + 1) % MM_PAGE_SIZE;
|
|
|
|
if ((char *)end + 1 - (char *)start < MM_PAGE_SIZE<<1) {
|
|
print("Error: Supplied memory area(%x,%x) is smaller than the page size (%d)\n", (unsigned int)start, (unsigned int)end, MM_PAGE_SIZE);
|
|
return;
|
|
}
|
|
|
|
//reserve enough pages at the front of this chunk of memory to hold the
|
|
//page structs, then build the structs and add them to the list
|
|
|
|
//TODO we're potentially losing memory here because we're calculating
|
|
//the number of page structs we need even for those pages that will contain only page structs
|
|
num_pages = ((char *)end + 1 - (char *)start) / MM_PAGE_SIZE;
|
|
usable_pages = num_pages - num_pages * sizeof(struct page) / MM_PAGE_SIZE;
|
|
if (num_pages * sizeof(struct page) % MM_PAGE_SIZE)
|
|
usable_pages--;
|
|
|
|
p = (struct page *)start;
|
|
for (page = ((char *)start) + (num_pages - usable_pages)*MM_PAGE_SIZE; page < end; page = (void *)(((char *)page) + MM_PAGE_SIZE)) {
|
|
p->address = page;
|
|
insert_page(p);
|
|
p++;
|
|
}
|
|
}
|
|
|
|
struct page* mm_get_free_pages(unsigned int power) {
|
|
unsigned int num_pages = 1<<power;
|
|
struct page *it;
|
|
|
|
print("power: %d\n", num_pages);
|
|
|
|
if (list_empty(&mm_free_page_list)) {
|
|
print("Error: Out of memory\n");
|
|
return (struct page*)0;
|
|
}
|
|
|
|
for_each_list(it, &mm_free_page_list, struct page, list) {
|
|
unsigned int curr_pages = 1;
|
|
struct page *it2;
|
|
for (it2 = container(it->list.next, struct page, list);
|
|
it2->list.next != &mm_free_page_list && curr_pages < num_pages;
|
|
it2 = container(it2->list.next, struct page, list)) {
|
|
if ((char*)it2->address != (char*)container(it2->list.prev, struct page, list)->address + MM_PAGE_SIZE) {
|
|
it = it2; //fast-forward 'it' to start of next contiguous section of pages
|
|
break;
|
|
} else {
|
|
curr_pages++;
|
|
}
|
|
}
|
|
if (curr_pages == num_pages) {
|
|
remove_splice(&it->list, it2->list.prev);
|
|
return it;
|
|
}
|
|
}
|
|
return (struct page*)0;
|
|
}
|
|
|
|
int mm_put_free_pages(struct page *p) {
|
|
struct page *it;
|
|
for_each_list(it, &mm_free_page_list, struct page, list) {
|
|
if (p->address < it->address) {
|
|
insert_splice_before(&it->list, &p->list, p->list.prev);
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|