paging.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 <assert.h>

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

#include <list.h>
#include <cpu_node.h>
#include <zone.h>
#include <page_frame.h>

#include <segment.h> /* For the IO_BITMAP_SIZE */
#include <x86.h>

struct pgde *s_rpgd;

static inline int reset_table(void *initm,
                struct pgde *pgd, unsigned long pma, unsigned long vma,
                size_t size)
{
        int pgt_idx;
        int page_idx;
        struct pgte *pgt;
        uint32_t tmp;
        register int i;

        TO_IDX(vma, pgt_idx, page_idx);

        while (size) {
                tmp = sysconf(_SC_PAGESIZE);

                if (!pgd[pgt_idx].p) {
                        tmp *= (NR_PAGES - page_idx);
                        if (size < tmp) {
                                break;
                        }
                        size -= tmp;
                        pgt_idx++;
                        page_idx = 0;
                        continue;
                }

                pgt = (struct pgte*)(pgd[pgt_idx].pt_base * tmp);
                pgt = initm_find_vma(pgt);

                while (page_idx < NR_PAGES && size >= tmp) {
                        pgt[page_idx].p = 0;
                        pgt[page_idx].page_base = 0;
                        page_idx++;
                        size -= tmp;
                }

                for (i = 0; i < NR_PAGES && !pgt[i].p; i++);
                if (i == NR_PAGES) {
                        pgd[pgt_idx].p = 0;
                        pgd[pgt_idx].pt_base = 0;

                        initm_free(initm, (char*)pgt);
                }

                if (page_idx == NR_PAGES) {
                        pgt_idx++;
                        page_idx = 0;
                }
        }

        reload_cr3();
        return 0;
}

static inline struct pgte *get_pgt(void *initm, struct pgde *pgd, int idx)
{
        struct pgte *pgt;
        uint32_t pagesize;

        pagesize = sysconf(_SC_PAGESIZE);
        if (pgd[idx].p) {
                pgt = (struct pgte *)(pgd[idx].pt_base * pagesize);
                dbg_printf("Allocated PGT: %p\n", pgt);
                return pgt;
        }

        pgt = (struct pgte *)initm_alloc(initm);
        if (!pgt) {
                dbg_printf("Failed to allocate pgt\n");
                return NULL;
        }

        memset(pgt, 0, pagesize);
        pgd[idx].p = 1;
        pgd[idx].rw = 1;
        pgd[idx].pt_base = (uint32_t)pgt / pagesize;

        return pgt;
}

static inline int setup_table(void *initm, struct pgde *pgd,
                                uint32_t pma, uint32_t vma, ssize_t size)
{
        int pgt_idx;
        int page_idx;
        struct pgte *pgt;
        uint32_t pagesize;

        pagesize = sysconf(_SC_PAGESIZE);

        pma /= pagesize;
        size /= pagesize;
        TO_IDX(vma, pgt_idx, page_idx);

        pgt = get_pgt(initm, pgd, pgt_idx);
        if (!pgt) {
                return -EINVAL;
        }

        while (size > 0) {
                if (pgt[page_idx].p) {
                        return -EFAULT;
                }

                pgt[page_idx].p = 1;
                pgt[page_idx].rw = 1;
                pgt[page_idx].page_base = pma;

                pma++;
                size--;
                page_idx++;

                if (page_idx == NR_PAGES) {
                        pgt_idx++;

                        if (pgt_idx == NR_TABLES) {
                                break;
                        }

                        pgt = get_pgt(initm, pgd, pgt_idx);
                        if (!pgt) {
                                return -EINVAL;
                        }

                        page_idx = 0;
                }
        }

        return 0;
}

int vm_init(struct memmap *map, uint32_t kvma)
{
        struct pgde *pgd;
        int ret;

        pgd = (struct pgde *)initm_alloc(map->initm);
        if (!pgd) {
                return -ENOMEM;
        }

        memset(pgd, 0, sysconf(_SC_PAGESIZE));

        ret = setup_table(map->initm, pgd, 0x0, 0x0, 1 << 20);
        if (ret < 0) {
                return ret;
        }

        ret = setup_table(map->initm, pgd,
                (uint32_t)map->env,
                (uint32_t)kvma,
                map->env_size + map->kernel_size +
                map->initm_size + map->heap_size);
        if (ret < 0) {
                return ret;
        }

        ret = setup_table(map->initm, pgd,
                (uint32_t)map->env + map->env_size + map->kernel_size +
                map->initm_size + map->heap_size,
                0xFFFFFFFF - (map->tcb_size + map->stack_size) + 1 - (0x01 << 20),
                map->tcb_size + map->stack_size);

        ret = setup_table(map->initm, pgd,
                (uint32_t)map->env, (uint32_t)map->env,
                map->env_size + map->kernel_size +
                map->initm_size + map->heap_size +
                map->stack_size + map->tcb_size
        );
        if (ret < 0) {
                return ret;
        }

        load_cr3(pgd);
        vm_enable();

        return 0;
}

int vm_init_done(struct memmap *map, unsigned long kpma)
{
        struct pgde *pgd;
        int ret;

        pgd = read_cr3();
        if (!pgd) {
                return -EFAULT;
        }

        pgd = initm_find_vma(pgd);
        reset_table(map->initm, pgd,
                        kpma, kpma,
                        map->env_size + map->kernel_size +
                        map->initm_size + map->heap_size +
                        map->stack_size + map->tcb_size);

        s_rpgd = initm_alloc(map->initm);
        if (!s_rpgd) {
                return -ENOMEM;
        }

        memset(s_rpgd, 0, sysconf(_SC_PAGESIZE));

        ret = setup_table(map->initm, s_rpgd,
                                (uint32_t)0, (uint32_t)0, 1 << 20);
        if (ret < 0) {
                return ret;
        }

        ret = setup_table(map->initm, s_rpgd,
                (uint32_t)map->env,
                (uint32_t)kpma,
                map->env_size + map->kernel_size +
                map->initm_size + map->heap_size);
        if (ret < 0) {
                return ret;
        }

        ret = setup_table(map->initm, s_rpgd,
                (0xFFFFFFFF - (map->tcb_size + map->stack_size)) + 1 - (0x01 << 20),
                (uint32_t)map->env + map->env_size + map->kernel_size +
                map->initm_size + map->heap_size,
                map->tcb_size + map->stack_size);

        return 0;
}

void vm_enable(void)
{
        register unsigned int cr0;

        asm volatile ("movl %%cr0, %0":"=r"(cr0):);
        cr0 |= 0x80000000;
        asm volatile ("movl %0, %%cr0"::"r"(cr0));
}

int vm_is_enabled(void)
{
        register unsigned int cr0;

        asm volatile ("mov %%cr0, %0":"=r"(cr0):);
        return !!(cr0 & 0x80000000);
}

int vm_frame_init(int memcnt, int membase[], int memsize[])
{
        struct node *node;
        int i;
        enum zone_type zone[] = {
                ZONE_BASE,
                ZONE_NORMAL,
                ZONE_HIMEM,
        };

        if (memcnt > ZONE_HIMEM) {
                return -EINVAL;
        }

        node = cpu_node_create(0);
        for (i = 0; i < memcnt; i++) {
                if (!memsize[i]) {
                        continue;
                }

                if (create_zone(node, zone[i], membase[i], memsize[i]) < 0) {
                        continue;
                }

                dbg_printf("ZONE[%d] is created\n", zone[i]);
        }

        i = create_zone(node, ZONE_SYSTEM, 0, 0);
        assert(i == 0 && "Failed to create ZONE_SYSTEM");
        dbg_printf("ZONE[%d] is created\n", ZONE_SYSTEM);

        return 0;
}

void *vm_rpgd()
{
        return s_rpgd;
}

/* End of a file */