src/memory/pager.hpp

Idź do dokumentacji tego pliku.

/*header file for src/memory/pager.cpp*/

#ifndef _CORE_MEMORY_PAGER_HPP
#define _CORE_MEMORY_PAGER_HPP

/* necessary includes */
#include "src/memory/mmap.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"

struct env_t;

/*enumerations for pte flags*/
const uint32 PTE_PRESENT        = 0x0001;       /*present*/
const uint32 PTE_WRITEABLE      = 0x0002;       /*can be written to*/
const uint32 PTE_RO             = 0x0000;       /*read only*/
const uint32 PTE_USER           = 0x0004;       /*user code can access it*/
const uint32 PTE_ACCESSED       = 0x0020;       /*has been read/written*/
const uint32 PTE_DIRTY          = 0x0040;       /*has been written to*/
const uint32 PTE_OS             = 0x0e00;       /*mask for os-specific data*/
const uint32 PTE_MASK           = 0x0fff;       /*mask for flags*/
/*pte flags for non-present pages*/
const uint32 PTE_LAZY           = 0x0200;       /*specifically for demand paging*/
const uint32 PTE_STACKGUARD     = 0x0004;       /*stackguard*/
const uint32 PTE_SHMEM          = 0x0400;       /*shared mem*/
// const uint32 PTE_INFO                = 0x0200;       /*so the lower bits are used for storing useful information*/
// const uint32 PTE_OBJ         = 0x0200;       /*other info about the page is specified in the process' mmap*/

extern char CRT_STACK;  //the lowest byte of the CRT stack
extern uint32 CRT_STACK_SIZE;//the first after it

extern int shmem_paging_pfh(struct env_t *en, uint32 virt, uint32 phys);        /* shmem.cpp */

namespace Memory {
namespace Pager {

extern uint32 lazy_enable;      //whether the lazy paging pfe handler has been installed
extern void *virtual_frame;     /*a pointer to the virtual frame*/

// extern unsigned char lazy_enable;

/*one address space*/
class memtree
 {
public:
        addr_t *page_directory;         //pointer to the page directory, virtual adress
        uint32 cr3;                     //the same, but physical address
//      uint32 flags;           //default flags
        mmap_t memory_map;      //memory map

        void init(addr_t *pgd, class Memory::Heap::heapbox *hp);        /*init to a given pgd data*/
        void done();    //done

/* basic */
        void pte_map (addr_t virt, uint32 value);       /*assign value to virt addr*/
        uint32 pte_val (addr_t virt);   /*get value assigned to virt addr*/
        void pte_umap (addr_t virt);    /*unassign a value from virt addr*/

/* extended */
        void pte_lazy(addr_t virt, uint32 flags);       /*setup a page for lazy paging*/
        int pte_alloc(addr_t virt, uint32 flags);       //alloc page or lazy, if enabled
 };
extern memtree kmem;            /*the handle for the NULL process' address space*/

void init();    /*initialise the pager*/
int allocate_memtree(class memtree *mtree, bool supervisor, class Memory::Heap::heapbox *hp);   //create a memory space, yea
void init_pf(); /* init custom page fault handling */
int PageFaultHandler(struct Arch::x86::Interr::except2_t *code);        //lazy, shmem etc.
int lazy_paging_pfh(struct env_t *en, uint32 virt, uint32 phys);

/*in order to maintain multiple address spaces regardlessly of the current one,
we use one virtual kernel-level page to which we assign any phisycal address we
need to access.*/

void frame_assign (addr_t physical);    /*assign an address to the frame page and lock this resource*/
void frame_release();                   /*release the frame*/

void FrameAssign (void *frame, class IPC::Lock::lock_t *l, addr_t physical);    /*assign an address to the frame page and lock this resource*/
void FrameRelease(class IPC::Lock::lock_t *l);                  /*release the frame*/

// void invalidate(addr_t virt);                /*invalidate the virt's addr in the translation lookaside buffer*/
#define invalidate(virt)        do {    \
                        __asm__ __volatile__("invlpg (%%eax)" : :"a"(virt));    \
                        } while (0)

// copy data from one physical page to another
void cpypage(uint32 dest, uint32 src);
//copy data from one memspace to another
void memmove2(class memtree *d1, void *d2, class memtree *s1, void *s2, uint32 cnt);

  }     /*namespace Pager*/
 };     /*namespace Memory*/

#endif

---