initm.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdarg.h>
#include <stdint.h>
#include <unistd.h>
#include <errno.h>

#include <arch.h>
#include <paging.h>
#include <initm.h>
#include <debug.h>

static struct info {
        void *initm_pma;
        void *initm_vma;
} s_info;

struct head_info;

struct tail_info {
        size_t sz;
        size_t free_sz;
        size_t nr_of_chunks;
        char *data;
        struct head_info *head;
}; /* size = sysconf(_SC_PAGESIZE) */

struct head_info {
        struct tail_info *tail;
        char bitmap[];
};

int initm_init(void *initm, size_t size)
{
        struct head_info *head;
        struct tail_info *tail;
        uint32_t pagesize;

        pagesize = sysconf(_SC_PAGESIZE);

        tail = (struct tail_info *)((char *)initm + size - pagesize);
        tail->sz = size;

        /* pagesize << 1 == HEAD + TAIL block */
        tail->free_sz = tail->sz - (pagesize << 1);

        tail->nr_of_chunks = tail->free_sz / pagesize;

        /* HEAD 영역을 제외한 부분 부터 Data 영역 시작 */
        tail->data = (char *)initm + pagesize;
        tail->head = initm;

        head = tail->head;
        head->tail = tail;
        memset(head->bitmap, 0, pagesize - sizeof(*head));

        return 0;
}

size_t initm_size(void *initm)
{
        struct head_info *head;
        struct tail_info *tail;

        head = initm;
        tail = head->tail;

        return tail->sz;
}

size_t initm_free_size(void *initm)
{
        struct head_info *head;
        struct tail_info *tail;

        head = initm;
        tail = head->tail;

        return tail->free_sz;
}

void *initm_alloc(void *initm)
{
        char *data;
        register int idx;
        register unsigned char bit;
        register int byte;
        struct tail_info *tail;
        struct head_info *head;

        head = (struct head_info*)initm;
        tail = head->tail;
        data = tail->data;

        for (idx = 0; idx < tail->nr_of_chunks; idx++) {
                byte = idx >> 3;
                bit = 0x01 << (idx & 0x07);

                if (!(head->bitmap[byte] & bit)) {
                        head->bitmap[byte] |= bit;
                        tail->free_sz -= sysconf(_SC_PAGESIZE);
                        return data + idx * sysconf(_SC_PAGESIZE);
                }
        }

        return NULL;
}

int initm_free(void *initm, void *addr)
{
        char *data;
        unsigned char bit_idx;
        int byte_idx;
        struct tail_info *tail;
        struct head_info *head;

        head = (struct head_info*)initm;
        tail = head->tail;
        data = tail->data;

        byte_idx = ((char *)addr - data) >> 3;
        bit_idx = ((char *)addr - data) & 0x07;

        if (!(head->bitmap[byte_idx] & (0x01 << bit_idx))) {
                return -ENOENT;
        }

        head->bitmap[byte_idx] &= ~(0x01 << bit_idx);
        tail->free_sz += sysconf(_SC_PAGESIZE);
        return 0;
}

void *initm_vma(void)
{
        return s_info.initm_vma;
}

/* initm_find_vma 함수를 사용하기 전에, initm_set_pma 함수를 이용해
 * Physical memory 상의 INITM 시작 주소를 지정해 주어야 한다 
 *
 * 가상 메모리가 활성화 된 이후에 호출 되어야 한다.
 * s_info.initm_pma 는 가상 메모리상의 주소를 가지고 있기 때문에
 * 가상 메모리가 활성화 되기 전에 사용하면 문제가 발생한다.
 */
void initm_set_pma(void *initm)
{
        s_info.initm_pma = initm;
}

void initm_set_vma(void *initm)
{
        s_info.initm_vma = initm;
}

void *initm_pma(void)
{
        return s_info.initm_pma;
}

/*
 * 반드시 initm_set_pma 가 호출 되어 있어야 한다.
 */
void *initm_find_vma(void *pma)
{
        char *vma;
        uint32_t gap;

        gap = (uint32_t)pma - (uint32_t)s_info.initm_pma;
        vma = (char *)initm_vma() + gap;

        return vma;
}

void *initm_find_pma(void *vma)
{
        char *pma;

        uint32_t gap;
        gap = (uint32_t)vma - (uint32_t)initm_vma();
        pma = (char *)initm_pma() + gap;

        return pma;
}

/*
 * 반드시 initm_set_pma 가 호출 되어 있어야 한다.
 */
void initm_update_for_vma(void)
{
        struct tail_info *tail;
        struct head_info *head;

        head = initm_vma();
        head->tail = initm_find_vma(head->tail);
        tail = head->tail;
        tail->head = head;
        tail->data = initm_find_vma(tail->data);
}

/* End of a file */