mmu.c File Reference

#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include "threads/init.h"
#include "threads/pte.h"
#include "threads/palloc.h"
#include "threads/thread.h"
#include "threads/mmu.h"
#include "intrinsic.h"

Include dependency graph for mmu.c:

Functions
static uint64_t *	pgdir_walk (uint64_t *pdp, const uint64_t va, int create)
static uint64_t *	pdpe_walk (uint64_t *pdpe, const uint64_t va, int create)
uint64_t *	pml4e_walk (uint64_t *pml4e, const uint64_t va, int create)
uint64_t *	pml4_create (void)
static bool	pt_for_each (uint64_t *pt, pte_for_each_func *func, void *aux, unsigned pml4_index, unsigned pdp_index, unsigned pdx_index)
static bool	pgdir_for_each (uint64_t *pdp, pte_for_each_func *func, void *aux, unsigned pml4_index, unsigned pdp_index)
static bool	pdp_for_each (uint64_t *pdp, pte_for_each_func *func, void *aux, unsigned pml4_index)
bool	pml4_for_each (uint64_t *pml4, pte_for_each_func *func, void *aux)
static void	pt_destroy (uint64_t *pt)
static void	pgdir_destroy (uint64_t *pdp)
static void	pdpe_destroy (uint64_t *pdpe)
void	pml4_destroy (uint64_t *pml4)
void	pml4_activate (uint64_t *pml4)
void *	pml4_get_page (uint64_t *pml4, const void *uaddr)
bool	pml4_set_page (uint64_t *pml4, void *upage, void *kpage, bool rw)
void	pml4_clear_page (uint64_t *pml4, void *upage)
bool	pml4_is_dirty (uint64_t *pml4, const void *vpage)
void	pml4_set_dirty (uint64_t *pml4, const void *vpage, bool dirty)
bool	pml4_is_accessed (uint64_t *pml4, const void *vpage)
void	pml4_set_accessed (uint64_t *pml4, const void *vpage, bool accessed)

Function Documentation

pdp_for_each()

static bool pdp_for_each ( uint64_t *  pdp, pte_for_each_func *  func, void *  aux, unsigned  pml4_index  )

static

                                                                 {
    for (unsigned i = 0; i < PGSIZE / sizeof(uint64_t *); i++) {
        uint64_t *pde = ptov((uint64_t *) pdp[i]);
        if (((uint64_t) pde) & PTE_P)
            if (!pgdir_for_each ((uint64_t *) PTE_ADDR (pde), func,
                     aux, pml4_index, i))
                return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pdpe_destroy()

static void pdpe_destroy ( uint64_t *  pdpe )

static

                              {
    for (unsigned i = 0; i < PGSIZE / sizeof(uint64_t *); i++) {
        uint64_t *pde = ptov((uint64_t *) pdpe[i]);
        if (((uint64_t) pde) & PTE_P)
            pgdir_destroy ((void *) PTE_ADDR (pde));
    }
    palloc_free_page ((void *) pdpe);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pdpe_walk()

static uint64_t * pdpe_walk ( uint64_t *  pdpe, const uint64_t  va, int  create  )

static

                                                          {
    uint64_t *pte = NULL;
    int idx = PDPE (va);
    int allocated = 0;
    if (pdpe) {
        uint64_t *pde = (uint64_t *) pdpe[idx];
        if (!((uint64_t) pde & PTE_P)) {
            if (create) {
                uint64_t *new_page = palloc_get_page (PAL_ZERO);
                if (new_page) {
                    pdpe[idx] = vtop (new_page) | PTE_U | PTE_W | PTE_P;
                    allocated = 1;
                } else
                    return NULL;
            } else
                return NULL;
        }
        pte = pgdir_walk (ptov (PTE_ADDR (pdpe[idx])), va, create);
    }
    if (pte == NULL && allocated) {
        palloc_free_page ((void *) ptov (PTE_ADDR (pdpe[idx])));
        pdpe[idx] = 0;
    }
    return pte;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgdir_destroy()

static void pgdir_destroy ( uint64_t *  pdp )

static

                              {
    for (unsigned i = 0; i < PGSIZE / sizeof(uint64_t *); i++) {
        uint64_t *pte = ptov((uint64_t *) pdp[i]);
        if (((uint64_t) pte) & PTE_P)
            pt_destroy (PTE_ADDR (pte));
    }
    palloc_free_page ((void *) pdp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgdir_for_each()

static bool pgdir_for_each ( uint64_t *  pdp, pte_for_each_func *  func, void *  aux, unsigned  pml4_index, unsigned  pdp_index  )

static

                                                 {
    for (unsigned i = 0; i < PGSIZE / sizeof(uint64_t *); i++) {
        uint64_t *pte = ptov((uint64_t *) pdp[i]);
        if (((uint64_t) pte) & PTE_P)
            if (!pt_for_each ((uint64_t *) PTE_ADDR (pte), func, aux,
                    pml4_index, pdp_index, i))
                return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pgdir_walk()

static uint64_t * pgdir_walk ( uint64_t *  pdp, const uint64_t  va, int  create  )

static

                                                          {
    int idx = PDX (va);
    if (pdp) {
        uint64_t *pte = (uint64_t *) pdp[idx];
        if (!((uint64_t) pte & PTE_P)) {
            if (create) {
                uint64_t *new_page = palloc_get_page (PAL_ZERO);
                if (new_page)
                    pdp[idx] = vtop (new_page) | PTE_U | PTE_W | PTE_P;
                else
                    return NULL;
            } else
                return NULL;
        }
        return (uint64_t *) ptov (PTE_ADDR (pdp[idx]) + 8 * PTX (va));
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_activate()

void pml4_activate

(

uint64_t *

pml4

)

                               {
    lcr3 (vtop (pml4 ? pml4 : base_pml4));
}

Here is the caller graph for this function:

pml4_clear_page()

void pml4_clear_page	(	uint64_t *	pml4,
		void *	upage
	)

                                              {
    uint64_t *pte;
    ASSERT (pg_ofs (upage) == 0);
    ASSERT (is_user_vaddr (upage));
 
    pte = pml4e_walk (pml4, (uint64_t) upage, false);
 
    if (pte != NULL && (*pte & PTE_P) != 0) {
        *pte &= ~PTE_P;
        if (rcr3 () == vtop (pml4))
            invlpg ((uint64_t) upage);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_create()

uint64_t * pml4_create

(

void

)

                   {
    uint64_t *pml4 = palloc_get_page (0);
    if (pml4)
        memcpy (pml4, base_pml4, PGSIZE);
    return pml4;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_destroy()

void pml4_destroy

(

uint64_t *

pml4

)

                              {
    if (pml4 == NULL)
        return;
    ASSERT (pml4 != base_pml4);
 
    /* if PML4 (vaddr) >= 1, it's kernel space by define. */
    uint64_t *pdpe = ptov ((uint64_t *) pml4[0]);
    if (((uint64_t) pdpe) & PTE_P)
        pdpe_destroy ((void *) PTE_ADDR (pdpe));
    palloc_free_page ((void *) pml4);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_for_each()

bool pml4_for_each	(	uint64_t *	pml4,
		pte_for_each_func *	func,
		void *	aux
	)

                                                                   {
    for (unsigned i = 0; i < PGSIZE / sizeof(uint64_t *); i++) {
        uint64_t *pdpe = ptov((uint64_t *) pml4[i]);
        if (((uint64_t) pdpe) & PTE_P)
            if (!pdp_for_each ((uint64_t *) PTE_ADDR (pdpe), func, aux, i))
                return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_get_page()

void * pml4_get_page	(	uint64_t *	pml4,
		const void *	uaddr
	)

                                                  {
    ASSERT (is_user_vaddr (uaddr));
 
    uint64_t *pte = pml4e_walk (pml4, (uint64_t) uaddr, 0);
 
    if (pte && (*pte & PTE_P))
        return ptov (PTE_ADDR (*pte)) + pg_ofs (uaddr);
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_is_accessed()

bool pml4_is_accessed	(	uint64_t *	pml4,
		const void *	vpage
	)

                                                     {
    uint64_t *pte = pml4e_walk (pml4, (uint64_t) vpage, false);
    return pte != NULL && (*pte & PTE_A) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_is_dirty()

bool pml4_is_dirty	(	uint64_t *	pml4,
		const void *	vpage
	)

                                                  {
    uint64_t *pte = pml4e_walk (pml4, (uint64_t) vpage, false);
    return pte != NULL && (*pte & PTE_D) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_set_accessed()

void pml4_set_accessed	(	uint64_t *	pml4,
		const void *	vpage,
		bool	accessed
	)

                                                                     {
    uint64_t *pte = pml4e_walk (pml4, (uint64_t) vpage, false);
    if (pte) {
        if (accessed)
            *pte |= PTE_A;
        else
            *pte &= ~(uint32_t) PTE_A;
 
        if (rcr3 () == vtop (pml4))
            invlpg ((uint64_t) vpage);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_set_dirty()

void pml4_set_dirty	(	uint64_t *	pml4,
		const void *	vpage,
		bool	dirty
	)

                                                               {
    uint64_t *pte = pml4e_walk (pml4, (uint64_t) vpage, false);
    if (pte) {
        if (dirty)
            *pte |= PTE_D;
        else
            *pte &= ~(uint32_t) PTE_D;
 
        if (rcr3 () == vtop (pml4))
            invlpg ((uint64_t) vpage);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4_set_page()

bool pml4_set_page	(	uint64_t *	pml4,
		void *	upage,
		void *	kpage,
		bool	rw
	)

                                                                  {
    ASSERT (pg_ofs (upage) == 0);
    ASSERT (pg_ofs (kpage) == 0);
    ASSERT (is_user_vaddr (upage));
    ASSERT (pml4 != base_pml4);
 
    uint64_t *pte = pml4e_walk (pml4, (uint64_t) upage, 1);
 
    if (pte)
        *pte = vtop (kpage) | PTE_P | (rw ? PTE_W : 0) | PTE_U;
    return pte != NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pml4e_walk()

uint64_t * pml4e_walk	(	uint64_t *	pml4e,
		const uint64_t	va,
		int	create
	)

                                                            {
    uint64_t *pte = NULL;
    int idx = PML4 (va);
    int allocated = 0;
    if (pml4e) {
        uint64_t *pdpe = (uint64_t *) pml4e[idx];
        if (!((uint64_t) pdpe & PTE_P)) {
            if (create) {
                uint64_t *new_page = palloc_get_page (PAL_ZERO);
                if (new_page) {
                    pml4e[idx] = vtop (new_page) | PTE_U | PTE_W | PTE_P;
                    allocated = 1;
                } else
                    return NULL;
            } else
                return NULL;
        }
        pte = pdpe_walk (ptov (PTE_ADDR (pml4e[idx])), va, create);
    }
    if (pte == NULL && allocated) {
        palloc_free_page ((void *) ptov (PTE_ADDR (pml4e[idx])));
        pml4e[idx] = 0;
    }
    return pte;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pt_destroy()

static void pt_destroy ( uint64_t *  pt )

static

                          {
    for (unsigned i = 0; i < PGSIZE / sizeof(uint64_t *); i++) {
        uint64_t *pte = ptov((uint64_t *) pt[i]);
        if (((uint64_t) pte) & PTE_P)
            palloc_free_page ((void *) PTE_ADDR (pte));
    }
    palloc_free_page ((void *) pt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pt_for_each()

static bool pt_for_each ( uint64_t *  pt, pte_for_each_func *  func, void *  aux, unsigned  pml4_index, unsigned  pdp_index, unsigned  pdx_index  )

static

                                                                     {
    for (unsigned i = 0; i < PGSIZE / sizeof(uint64_t *); i++) {
        uint64_t *pte = &pt[i];
        if (((uint64_t) *pte) & PTE_P) {
            void *va = (void *) (((uint64_t) pml4_index << PML4SHIFT) |
                                 ((uint64_t) pdp_index << PDPESHIFT) |
                                 ((uint64_t) pdx_index << PDXSHIFT) |
                                 ((uint64_t) i << PTXSHIFT));
            if (!func (pte, va, aux))
                return false;
        }
    }
    return true;
}

Here is the caller graph for this function: