onetime_map.c

Go to the documentation of this file.

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

#include <object.h>
#include <list.h>
#include <initm.h>
#include <onetime_map.h>
#include <thread.h>
#include <paging.h>
#include <segment.h> /* For the IO_BITMAP_SIZE */
#include <x86.h> /* struct x86_arch_data */

#include <debug.h>

struct info {
        uint32_t vma_start;
        uint32_t vma_end;

        uint32_t *bitmap;
        uint32_t bitmap_sz;
} s_info = {
        .vma_start = 0,
        .vma_end = 0,

        .bitmap = NULL,
        .bitmap_sz = 0,
};

static inline void *set_pgt(uint32_t idx, void *pma)
{
        void *vma;
        uint32_t pgt_idx;
        struct thread *thid;
        struct pgte *pgt;
        struct pgde *pgd;
        struct x86_arch_data *arch_data;

        vma = (void *)(idx * sysconf(_SC_PAGESIZE) + s_info.vma_start);
        TO_IDX(vma, pgt_idx, idx);

        thid = (struct thread *)pthread_self();
        if (!thid) {
                return NULL;
        }

        thid = thid->root;
        if (!thid) {
                return NULL;
        }

        arch_data = thid->arch_data;

        pgd = initm_find_vma(arch_data->pma_pgd);
        assert(pgd && pgd[pgt_idx].p && "Failed to get valid PGD");

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

        assert(!pgt[idx].p && "Page table is already in use");

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

        return vma;
}

void *onetime_map(void *pma)
{
        uint32_t idx;
        register int i;
        register int j;
        void *vma = NULL;
        char *byte;

        /* 더블 워드 단위로 접근 */
        idx = s_info.bitmap_sz >> 2;
        for (i = 0; i < idx; i++) {
                if ((s_info.bitmap[i] & 0xFFFFFFFF) == 0xFFFFFFFF) {
                        continue; /* 빈 곳이 없다 */
                }

                for (j = 0; j < 32; j++) {
                        idx = 0x01 << j;
                        if ((s_info.bitmap[i] & idx) == idx) {
                                continue;
                        }

                        /* 빈 곳을 찾았다
                         * 마크 하고, 위치를 찾아서,
                         * 실제 주소를 계산한다.
                         */
                        s_info.bitmap[i] |= idx;

                        idx = (i << 5) + j;

                        vma = set_pgt(idx, pma);
                        return vma;
                }
        }

        /* 바이트 단위로 접근 */
        byte = (char *)s_info.bitmap;
        for (i <<= 2; i < s_info.bitmap_sz; i++) {
                if ((byte[i] & 0xFF) == 0xFF) {
                        continue;
                }

                for (j = 0; j < 8; j++) {
                        idx = 0x01 << j;
                        if ((byte[i] & idx) == idx) {
                                continue;
                        }

                        byte[i] |= idx;

                        idx = (i << 3) + j;

                        vma = set_pgt(idx, pma);
                        return vma;
                }
        }

        return NULL;
}

void *onetime_unmap(void *vma)
{
        uint32_t idx;
        uint32_t pgt_idx;
        struct thread *thid;
        struct x86_arch_data *arch_data;
        struct pgde *pgd;
        struct pgte *pgt;
        void *pma;

        if ((uint32_t)vma < s_info.vma_start || (uint32_t)vma > s_info.vma_end) {
                return NULL;
        }

        thid = (struct thread *)pthread_self();
        if (!thid) {
                return NULL;
        }

        thid = thid->root;
        if (!thid) {
                return NULL;
        }

        arch_data = thid->arch_data;

        pgd = initm_find_vma(arch_data->pma_pgd);
        if (!pgd) {
                return NULL;
        }

        TO_IDX(vma, pgt_idx, idx);

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

        /* 응? 페이지가 할당 되어 있지 않다고? */
        assert(pgt && pgt[idx].p && "Page table is not valid");

        /* 페이지 테이블 정보 갱신 */
        pgt[idx].p = 0;
        pma = (void *)(pgt[idx].page_base * sysconf(_SC_PAGESIZE));

        idx = ((uint32_t)vma - s_info.vma_start) / sysconf(_SC_PAGESIZE);

        s_info.bitmap[idx >> 5] &= ~(0x01 << (idx & 0x01F));
        return pma;
}

void onetime_map_init(void *vma_start, void *vma_end)
{
        struct pgde *pgd;
        struct pgte *pgt;
        int pgt_idx;
        int idx;
        struct thread *thid;
        struct x86_arch_data *arch_data;
        uint32_t iterator;
        void *initm;

        thid = (struct thread *)pthread_self();
        if (!thid) {
                return;
        }

        thid = thid->root;
        if (!thid) {
                return;
        }

        arch_data = thid->arch_data;
        pgd = initm_find_vma(arch_data->pma_pgd);
        if (!pgd) {
                return;
        }

        s_info.vma_start = (uint32_t)vma_start;
        s_info.vma_end = (uint32_t)vma_end;

        s_info.bitmap_sz =
                ((s_info.vma_end - s_info.vma_start) + 1) / sysconf(_SC_PAGESIZE);
        s_info.bitmap_sz >>= 3;
        s_info.bitmap_sz += !!(s_info.bitmap_sz & 0x07);

        s_info.bitmap = malloc(s_info.bitmap_sz);
        if (!s_info.bitmap) {
                return;
        }

        memset(s_info.bitmap, 0, s_info.bitmap_sz);

        initm = initm_vma();

        iterator = s_info.vma_start;
        while ((s_info.vma_end - iterator) >= sysconf(_SC_PAGESIZE)) {
                TO_IDX(iterator, pgt_idx, idx);
                iterator += sysconf(_SC_PAGESIZE);

                if (pgd[pgt_idx].p) {
                        continue;
                }

                pgt = initm_alloc(initm);
                if (!pgt) {
                        break;
                }

                memset(pgt, 0, sysconf(_SC_PAGESIZE));
                pgd[pgt_idx].pt_base = ((uint32_t)initm_find_pma(pgt) / sysconf(_SC_PAGESIZE));
                pgd[pgt_idx].p = 1;
                pgd[pgt_idx].rw = 1;
        }
}

/* End of a file */