page_fault_handler.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdio.h>
#include <time.h>
#include <semaphore.h>
#include <assert.h>
#include <pthread.h>
#include <stddef.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include <object.h>
#include <list.h>
#include <thread.h>
#include <paging.h> /* cr3 */
#include <isr.h> /* ecode */

#include <segment.h> /* For the IO_BITMAP_SIZE */
#include <x86.h> /* x86_arch_data */
#include <arch.h> /* halt */
#include <initm.h>

#include <debug.h>

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

#include <onetime_map.h>

static inline void *set_new_page(struct pgte *pgt, int page_idx)
{
        void *page;

        page = page_frame_alloc(ZONE_NORMAL, 1);
        assert(page && "Failed to allocate page");

        page = onetime_map(page);
        assert(page && "Failed to do page mapping");
        
        memset(page, 0, sysconf(_SC_PAGESIZE));

        page = onetime_unmap(page);
        assert(page && "Failed to do unmapping");

        pgt[page_idx].p = 1;
        pgt[page_idx].rw = 1;
        pgt[page_idx].page_base = ((uint32_t)page) / sysconf(_SC_PAGESIZE);

        return page;
}

static inline void update_rpgd(void *_p, uint32_t vma)
{
        struct thread *tcb;
        struct x86_arch_data *arch_data;
        int pgt_idx;
        int page_idx;
        struct pgte *pgt;
        struct pgde *rpgd;
        unsigned long page;
        const unsigned long pagesize = sysconf(_SC_PAGESIZE);
        uint32_t kernel_start;
        const char *kvma;
        char *endptr;

        kvma = getenv("kvma");
        assert(kvma && "KVMA is not valid");
        kernel_start = strtoul(kvma, &endptr, 16);

        page = (unsigned long)_p;
        dbg_printf("Update vma: %p, page: %p (kvma:%p)\n", vma, page, kernel_start);

        tcb = (struct thread *)pthread_self();
        assert(tcb && "Invalid tcb");

        arch_data = (struct x86_arch_data *)tcb->arch_data;
        assert(arch_data && "Invalid arch data");

        TO_IDX(page, pgt_idx, page_idx);
        rpgd = arch_data->rpgd;
        assert(rpgd && "rPGD is not valid");

        if (kernel_start <= vma) {
                struct thread *root_tcb;
                struct pgde *root_rpgd;
                struct x86_arch_data *root_arch_data;

                root_tcb = tcb->root;
                assert(root_tcb && "root TCB is not valid");

                root_arch_data = root_tcb->arch_data;
                root_rpgd = root_arch_data->rpgd;
                assert(root_rpgd && "rPGD is not valid");

                if (!root_rpgd[pgt_idx].p) {
                        pgt = malloc(pagesize);
                        assert(pgt && "Failed to allocate rpgt");

                        memset(pgt, 0, pagesize);

                        root_rpgd[pgt_idx].p = 1;
                        root_rpgd[pgt_idx].rw = 1;
                        root_rpgd[pgt_idx].pt_base = (uint32_t)pgt / pagesize;
                } else {
                        pgt = (struct pgte *)(root_rpgd[pgt_idx].pt_base * pagesize);
                }
        } else if (!rpgd[pgt_idx].p) {
                pgt = malloc(pagesize);
                assert(pgt && "Failed to allocate table");

                memset(pgt, 0, pagesize);
        }

        rpgd[pgt_idx].p = 1;
        rpgd[pgt_idx].rw = 1;
        rpgd[pgt_idx].pt_base = (uint32_t)pgt / pagesize;

        assert(!pgt[page_idx].p && "rpgd, page exists");

        pgt[page_idx].p = 1;
        pgt[page_idx].rw = 1;
        pgt[page_idx].page_base = (uint32_t)vma / pagesize;
}

static inline void set_new_pgt(struct pgde *pgd, int pgt_idx)
{
        struct x86_arch_data *arch_data;
        struct pgde *root_pgd;
        uint32_t kernel_start;
        struct thread *tcb;
        const char *kvma;
        int kpage_idx;
        int kpgt_idx;
        char *endptr;
        void *page;

        kvma = getenv("kvma");
        assert(kvma && "kvma is not valid");

        kernel_start = strtoul(kvma, &endptr, 16);
        TO_IDX(kernel_start, kpgt_idx, kpage_idx);

        tcb = pthread_self();
        assert(tcb && "TCB is not valid");

        if (tcb->root) {
                tcb = tcb->root;
        }

        arch_data = tcb->arch_data;
        assert(arch_data && "arch_data is not valid");

        root_pgd = onetime_map(arch_data->pma_pgd);
        assert(root_pgd && "failed to do onetime mapping");

        page = NULL;
        if (pgt_idx >= kpgt_idx && root_pgd != pgd) {
                if (root_pgd[pgt_idx].p) {
                        page = (void *)(root_pgd[pgt_idx].pt_base * sysconf(_SC_PAGESIZE));
                }
        }

        if (!page) {
                page = page_frame_alloc(ZONE_NORMAL, 1);
                assert(page && "Failed to allocate");

                page = onetime_map(page);
                assert(page && "Failed to do mapping");

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

                page = onetime_unmap(page);
                assert(page && "Failed to do unmapping");
        }

        pgd[pgt_idx].p = 1;
        pgd[pgt_idx].rw = 1;
        pgd[pgt_idx].pt_base = ((uint32_t)page) / sysconf(_SC_PAGESIZE);

        if (pgt_idx >= kpgt_idx && root_pgd != pgd) {
                if (!root_pgd[pgt_idx].p) {
                        root_pgd[pgt_idx].p = 1;
                        root_pgd[pgt_idx].rw = 1;
                        root_pgd[pgt_idx].pt_base = pgd[pgt_idx].pt_base;
                }
        }

        root_pgd = onetime_unmap(root_pgd);
        assert(root_pgd && "PGD is not valid");
}

static inline void handle_write_error_for_page(struct pgte *pgt, int page_idx)
{
        void *new_page;
        void *page;

        page = (void *)(pgt[page_idx].page_base * sysconf(_SC_PAGESIZE));
        assert(page && "page is not valid");

        if (page_frame_refcnt(page) == 1) {
                pgt[page_idx].rw = 1;
                pgt = onetime_unmap(pgt);
                assert(pgt && "Failed to do onetime unmapping");
                return;
        }

        page_frame_free(page);

        new_page = page_frame_alloc(ZONE_NORMAL, 1);
        assert(new_page && "Failed to allocate a page frame");

        new_page = onetime_map(new_page);
        assert(new_page && "Failed to do onetime mapping");

        page = onetime_map(page);
        assert(page && "Failed to do onetime mapping");

        memcpy(new_page, page, sysconf(_SC_PAGESIZE));

        new_page = onetime_unmap(new_page);
        assert(new_page && "Failed to do unmapping");

        page = onetime_unmap(page);
        assert(page && "Failed to do unmapping");

        pgt[page_idx].rw = 1;
        pgt[page_idx].page_base = (unsigned long)new_page / sysconf(_SC_PAGESIZE);
}

static inline void handle_write_error_for_table(struct pgde *pgd, struct pgte *pgt, int pgt_idx)
{
        struct pgte *new_pgt;
        register int i;

        /* Read only but trying to write */
        if (page_frame_refcnt(pgt) == 1) {
                pgt = onetime_map(pgt);
                assert(pgt && "Failed to do onetime mapping");

                for (i = 0; i < NR_PAGES; i++) {
                        pgt[i].rw = 0;
                }

                pgt = onetime_unmap(pgt);
                assert(pgt && "Failed to do unmapping");

                pgd[pgt_idx].rw = 1;
                return;
        }

        new_pgt = page_frame_alloc(ZONE_NORMAL, 1);
        assert(new_pgt && "Failed to allocate a page frame");

        new_pgt = onetime_map(new_pgt);
        assert(new_pgt && "Failed to do onetime mapping");

        pgt = onetime_map(pgt);
        assert(pgt && "Failed to onetime mapping");

        memcpy(new_pgt, pgt, sysconf(_SC_PAGESIZE));
        for (i = 0; i < NR_PAGES; i++) {
                new_pgt[i].rw = 0;
        }

        new_pgt = onetime_unmap(new_pgt);
        assert(new_pgt && "Failed to do unmapping");

        pgt = onetime_unmap(pgt);
        assert(pgt && "Failed to do unmapping");

        pgd[pgt_idx].rw = 1;
        pgd[pgt_idx].pt_base = ((unsigned long)new_pgt / sysconf(_SC_PAGESIZE));

        page_frame_free(pgt);
}

int page_fault_handler(int sub_irq, void *info, void *data)
{
        uint32_t fault_vma;
        struct pgde *pgd;
        int pgt_idx;
        int page_idx;
        struct x86_arch_data *arch_data;
        struct thread *tcb;
        struct pt_regs *reg;

        tcb = pthread_self();
        assert(tcb && "Invalid TCB");

        reg = (struct pt_regs *)tcb->esp;
        assert(reg && "Invalid register");

        arch_data = tcb->arch_data;
        assert(arch_data && "Invalid arch data");

        pgd = onetime_map(arch_data->pma_pgd);
        assert(pgd && "Failed to do onetime mapping");

        asm volatile ("mov %%cr2, %0":"=a"(fault_vma):);

        TO_IDX(fault_vma, pgt_idx, page_idx);

        if (!pgd[pgt_idx].p) {
                assert(!reg->ecode.page_fault.present && "Page is already exists");
                set_new_pgt(pgd, pgt_idx);
        } else if (!pgd[pgt_idx].rw) {
                struct pgte *pgt;

                if (!reg->ecode.page_fault.write) {
                        panic("Unhnadled exception");
                }

                pgt = (struct pgte *)(pgd[pgt_idx].pt_base * sysconf(_SC_PAGESIZE));
                handle_write_error_for_table(pgd, pgt, pgt_idx);
        } else {
                struct pgte *pgt;

                pgt = (struct pgte *)(pgd[pgt_idx].pt_base * sysconf(_SC_PAGESIZE));

                pgt = onetime_map(pgt);
                assert(pgt && "pgt is not valid");

                if (pgt[page_idx].p) {
                        /* NOTE: Read/Write permission error check */
                        if (pgt[page_idx].rw || !reg->ecode.page_fault.write) {
                                panic("Unhandled exception");
                        }

                        dbg_printf("Write fault %p (%p)\n", fault_vma, reg->eip);

                        handle_write_error_for_page(pgt, page_idx);
                } else {
                        void *page;

                        assert(!reg->ecode.page_fault.present && "page is present");

                        page = set_new_page(pgt, page_idx);
                        update_rpgd(page, fault_vma);
                }

                pgt = onetime_unmap(pgt);
                assert(pgt && "pgt is not valid");
        }

        pgd = onetime_unmap(pgd);
        return 0;
}

/* End of a file */