page.c

#include "page.h"
#include "uart.h"

static inline void _clear(struct page* p)
{
    p->flags = 0;
}

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

static inline void _set_flag(struct page* p, uint8_t flags)
{
    p->flags |= flags;  /* or operation on the flags */
}

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

/* align the address to the border of page (4kB) */
static uint32_t _align_page(uint32_t address)
{
    uint32_t order = (1 << PAGE_ORDER) - 1;
    return (address + order) & (~order);
}

static uint32_t _num_pages = 0;
static uint32_t _alloc_start = 0;
static uint32_t _alloc_end = 0;

void page_init(void)
{
    /*
     * We reserved 8 pages (8 * 4096 Bytes) to hold the structure 
     * for page management. It should be enough to manage at most
     * 128 MB ( 8 * 4096 * 4096 Bytes)
     */
    _num_pages = (HEAP_SIZE / PAGE_SIZE) - NUM_RESERVED_PAGES;
    printf("HEAP_START = %x, HEAP_SIZE = %x, num of pages = %d\n", HEAP_START, HEAP_SIZE, _num_pages);
	
    struct page* ptrPage = (struct page *)HEAP_START;
    for (int i = 0; i < _num_pages; i++) {
        _clear(ptrPage);
        ptrPage++;
    }
    _alloc_start = _align_page(HEAP_START + NUM_RESERVED_PAGES * 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);
}

/* allocator */
// TODO: improve performance
void *page_alloc(int npages)
{
    int found = 0;
    struct page *ptrPage_i = (struct page *)HEAP_START;
    for (int i = 0; i <= (_num_pages - npages); i++) {
        if (_is_free(ptrPage_i)) {
            found = 1;
            struct page *ptrPage_j = ptrPage_i + 1;
            for (int j = i + 1; j <= (i + npages); j++) {
                if ( !_is_free(ptrPage_j) ) {
                    found = 0;
                    break;
                }
                ptrPage_j++;
            }
            /* Get a memory block which is enough for us,
             * return the actual start address of the first
             * page of this block.
             */
            if (found) {
                struct page *ptrPage_k = ptrPage_i;
                for (int k = i; k < (i + npages); k++) {
                    _set_flag(ptrPage_k, PAGE_TAKEN);
                    ptrPage_k++;
                }
                ptrPage_k--;
                _set_flag(ptrPage_k, PAGE_LAST);
                return (void *)(_alloc_start + i * PAGE_SIZE);
            }
        }
        ptrPage_i++;
    }
    return NULL;
}

/* Free the memory block */
void page_free(void *p)
{
    /* Assert if p is invalid */
    if (!p || (uint32_t)p >= _alloc_end) {
        return;
    }
    /* The first page descriptor of the memory block */
    struct page *ptrPage = (struct page *)HEAP_START;
    ptrPage += ((uint32_t)p - _alloc_start) / PAGE_SIZE;
    /* loop and clear all the page descriptors of this memory block */
    while (!_is_free(ptrPage)) {
        _clear(ptrPage);
        if(_is_last(ptrPage)){
            break;
        } else{
            ptrPage++;
        }
    }
}

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

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

    void *p3 = page_alloc(5);
    printf("p3 = 0x%x\n", p3);
    
    page_free(p1);
    p1 = NULL;
    
    page_free(p2);
    p2 = NULL;
    
    page_free(p3);
    p3 = NULL;
}