mmu.h File Reference

#include <stdbool.h>
#include <stdint.h>
#include "threads/pte.h"

Include dependency graph for mmu.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	desc_ptr

Macros
#define	is_writable(pte)   (*(pte) & PTE_W)
#define	is_user_pte(pte)   (*(pte) & PTE_U)
#define	is_kern_pte(pte)   (!is_user_pte (pte))
#define	pte_get_paddr(pte)   (pg_round_down(*(pte)))

Typedefs
typedef bool	pte_for_each_func(uint64_t *pte, void *va, void *aux)

Functions
uint64_t *	pml4e_walk (uint64_t *pml4, const uint64_t va, int create)
uint64_t *	pml4_create (void)
bool	pml4_for_each (uint64_t *, pte_for_each_func *, void *)
void	pml4_destroy (uint64_t *pml4)
void	pml4_activate (uint64_t *pml4)
void *	pml4_get_page (uint64_t *pml4, const void *upage)
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 *upage)
void	pml4_set_dirty (uint64_t *pml4, const void *upage, bool dirty)
bool	pml4_is_accessed (uint64_t *pml4, const void *upage)
void	pml4_set_accessed (uint64_t *pml4, const void *upage, bool accessed)
struct desc_ptr	__attribute__ ((packed))

Variables
uint16_t	size
uint64_t	address

Macro Definition Documentation

is_kern_pte

#define is_kern_pte

(

pte

)

(!is_user_pte (pte))

is_user_pte

#define is_user_pte

(

pte

)

(*(pte) & PTE_U)

is_writable

#define is_writable

(

pte

)

(*(pte) & PTE_W)

pte_get_paddr

#define pte_get_paddr

(

pte

)

(pg_round_down(*(pte)))

Typedef Documentation

pte_for_each_func

typedef bool pte_for_each_func(uint64_t *pte, void *va, void *aux)

Function Documentation

__attribute__()

struct desc_ptr __attribute__

(

(packed)

)

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 *	upage
	)

                                                  {
    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 *	upage
	)

                                                     {
    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 *	upage
	)

                                                  {
    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 *	upage,
		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 *	upage,
		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 *	pml4,
		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:

Variable Documentation

address

uint64_t address

size

uint16_t size