pgtab-old.c

Go to the documentation of this file.

/*
 * \brief   Virtual page-table facility
 * \author  Thomas Friebel <tf13@os.inf.tu-dresden.de>
 * \author  Christian Helmuth <ch12@os.inf.tu-dresden.de>
 * \date    2006-11-01
 *
 * Implementation of page tables for saving virt->phys assignments.
 *
 * FIXME: This works for 32-bit architectures only! (Mostly because of pgtab.h.)
 */

#include <l4/dde/ddekit/pgtab.h>

#include <l4/sys/l4int.h>
#include <l4/sys/consts.h>
#include <l4/util/macros.h>
#include <l4/dm_mem/dm_mem.h>
#include <l4/log/l4log.h>


/**********************************
 ** Page-table utility functions **
 **********************************/

/* some useful consts */
enum
{
        PDIR_SHIFT   = L4_SUPERPAGESHIFT,  /* readable alias */
        PDIR_MASK    = L4_SUPERPAGEMASK,   /* readable alias */
        PDIR_ENTRIES = (1 << (L4_MWORD_BITS - PDIR_SHIFT)),
        PTAB_ENTRIES = (1 << (PDIR_SHIFT - L4_PAGESHIFT)),
        PTAB_SIZE    = (sizeof(void*) * PTAB_ENTRIES)
};

/**
 * Page table entry.
 * bit 00-01: type, 0->largemalloc 1->slab page 2->contigmalloc (PTE_TYPE_*)
 * bit 02-11: size in number of pages
 * bit 12-31: physical page address
 */
typedef union
{
        unsigned compact;
        struct
        {
                unsigned type  :  2;
                unsigned pages : 10;
                unsigned phys  : 20;
        } components;
} ddekit_pte;

/**
 * Calculate offset of address in page directory - page-table number
 */
static inline unsigned pt_num(l4_addr_t addr) {
        return addr >> PDIR_SHIFT; }


/**
 * Calculate offset of address in page table - page number
 */
static inline unsigned pg_num(l4_addr_t addr) {
        return (addr & ~PDIR_MASK) >> L4_PAGESHIFT; }


/* page directory */
static ddekit_pte *page_dir[PDIR_ENTRIES];


/**
 * Get page-table entry
 */
static inline ddekit_pte ddekit_get_pte(void *p)
{
        l4_addr_t addr = (l4_mword_t)p;
        ddekit_pte *tab;

        tab = page_dir[pt_num(addr)];
        if (!tab) return (ddekit_pte) 0U;

        return tab[pg_num(addr)];
}


/**
 * Set page-table entry
 */
static inline void ddekit_set_pte(void *p, ddekit_pte pte)
{
        l4_addr_t addr = (l4_addr_t) p;
        ddekit_pte *tab;

        tab = page_dir[pt_num(addr)];
        if (!tab) {
                /* create new page table */
                tab = (ddekit_pte *)
                      l4dm_mem_allocate_named(PTAB_SIZE, L4DM_CONTIGUOUS|L4DM_PINNED|L4RM_MAP,
                                              "ddekit ptab");
                Assert(tab);

                memset(tab, 0, PTAB_SIZE);
                page_dir[pt_num(addr)] = tab;

                if (1) {
                        l4_addr_t a = l4_trunc_superpage(addr);
                        LOG("created page table for range [0x%08lx,0x%08lx) @ %p\n",
                             a, a + L4_SUPERPAGESIZE, tab);
                }

        }

        tab[pg_num(addr)] = pte;
}


/*****************************
 ** Page-table facility API **
 *****************************/

/**
 * Set virtual->physical mapping for VM region
 *
 * \param virtual   virtual start address for region
 * \param physical  physical start address for region
 * \param pages     number of pages in region
 * \param type      pte type for region
 */
void ddekit_pte_set_region(void *virtual, ddekit_addr_t physical, int pages, int type)
{
        ddekit_pte new;

#ifdef INVARIANTS
        ddekit_pte pte;
        /* assert pte not set yet */
        pte = ddekit_get_pte(virtual);
        LOGd(pte.compact, "first pte already set! pte=0x%04x", pte.compact);
#endif

        /* build pte */
        new.components.type  = type;
        new.components.pages = pages;
        new.components.phys  = physical >> L4_PAGESHIFT;

        /* set first pte */
        ddekit_set_pte(virtual, new);

        /* continuation pte-s don't have pages set */
        new.components.pages = 0;

        /* set continuation pte-s */
        for (pages--; pages; pages--) {
                /* prepare continuation pte */
                virtual += L4_PAGESIZE;
                new.components.phys++;

#ifdef INVARIANTS
                /* assert pte not set yet */
                pte = ddekit_get_pte(virtual);
                LOGd(pte.compact, "continuation pte already set! pte=0x%04x", pte.compact);
#endif

                /* set continuation pte */
                ddekit_set_pte(virtual, new);
        }
}


/**
 * Clear virtual->physical mapping for VM region
 *
 * \param virtual   virtual start address for region
 * \param type      pte type for region
 *
 * XXX unused page-tables not free'd
 */
void ddekit_pte_clear_region(void *virtual, int type)
{
        ddekit_pte pte;
        int pages = 0;
        pte = ddekit_get_pte(virtual);
        /* get number of pages from pte */
        pages = pte.components.pages;
        /* assert pages != 0 */
        if (pages==0) {
                LOG("continuation pte found at base");
                return;
        }
        /* assert pte set and of correct type */
#ifdef INVARIANTS
        LOGd(! pte.compact, "pte is already clear");
        LOGd(pte.components.type!=type, "pte of wrong type");
#endif
        /* clear first pte */
        ddekit_set_pte(virtual, (ddekit_pte) 0U);
        /* clear continuation pte-s */
        for (pages--; pages; pages--) {
                virtual += L4_PAGESIZE;

#ifdef INVARIANTS
                /* assert pte set and of correct type */
                pte = ddekit_get_pte(virtual);
                if (! pte.compact) {
                        LOG("pte is already clear");
                        break;
                }
                if (pte.components.type!=type) {
                        LOG("pte of wrong type");
                        break;
                }
                if (pte.components.pages) {
                        LOG("unexpected non-continuation pte found");
                        break;
                }
#endif

                ddekit_set_pte(virtual, (ddekit_pte) 0U);
        }
}

---