src/memory/pager.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       paager.cpp, version 1.0                            *
************************************************************
*                                                          *
*the pager, it maintains the paging's bookkeeping in pgds  *
*and pgts. It allows to access pgds,pgts of multiple       *
*address spaces any time.                                  *
*                                                          *
*23'04'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/ipc/lock.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/thread/thread.hpp"
#include "src/thread/scheduler.hpp"
#include "src/thread/process.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/memory/pager.hpp"

namespace Memory {
namespace Pager {


/*==============variables*/
IPC::Lock::lock_t lock_frame(const_cast<char*>("frame"));       /*the lock on the frame*/
void *virtual_frame;    /*a pointer to the virtual frame*/
memtree kmem;           /*the handle for the NULL process' address space*/
// grub didn't seem to zero the bss :-( because the value was properly filled in, if non-zero.
// extern uint32 lazy_enable __attribute__ ((section (".data")));
//UPDATE: except.s styled stacks were the problem. now it works :D
uint32 lazy_enable=0;   //whether the lazy paging pfe handler has been installed
// unsigned char lazy_enable=0xab;
// c00100d8

/*==============init*/
/*initialise the pager*/
void init() { _Pf("Pager::init");
addr_t *pgd;
/* init the kernel memory space book keeping */
        virtual_frame = (void*) Memory::Physical::ballocate(PAGE_SIZE, PAGE_ALIGN);
        __asm__ __volatile__ ("mov %%cr3, %%eax" : "=a" (pgd));
        kmem.cr3=(uint32)pgd;
        kmem.init((addr_t*)((uint32)pgd+mem_kernel_start-mem_physical), &Memory::Heap::heap0);
        kmem.memory_map.init(mem_space_start, mem_space_krnend, &Memory::Heap::heap0);
/* put a stackguard at the bottom of the crt_stack */
        kmem.pte_map(0xfffff000 & (uint32)&CRT_STACK, PTE_STACKGUARD);  //this page will be freed when multitasking is enabled

        preturn();
 }

/* init custom page fault handling */
void init_pf()
 { _Pf("Pager::init_pf");
        lazy_enable=true;
        Arch::x86::Interr::add2interr_chain(Arch::x86::Interr::INT_PF, &PageFaultHandler);

        preturn();
 }

//lazy, shmem etc.
int PageFaultHandler(struct Arch::x86::Interr::except2_t *code)
 {
 /*
 static int Aa=0;
 alert(Aa++);
 alert("\n");
 if (Aa == 0x2a) asm volatile ("cli\nhlt");
 */
 _Pf("'PageFaultHandler");
struct env_t env;
        env.code=code;
        env.thread=(Thread::Scheduler::multitasking_running? (Thread::thread_t*)current_thread:NULL);
        env.proc=(Thread::Scheduler::multitasking_running? current_thread->proc:NULL);
uint32 virt= code->cr2;
        env.mtree=(Thread::Scheduler::multitasking_running? current_thread->proc->mem : &kmem);
uint32 phys=env.mtree->pte_val(virt&0xfffff000);

// The shmem handler needs to ben ran first, because PTE_LAZY|PTE_SHMEM pages are being serviced by the shmem handler
//try shared memory handler
        if (shmem_paging_pfh(&env, virt, phys)==ESUCCESS) preturn( ESUCCESS );
//try demand paging
        if (lazy_paging_pfh(&env, virt, phys)==ESUCCESS) preturn( ESUCCESS );

        preturn( EFAIL);
 }

//lazy paging pf handler
int lazy_paging_pfh(struct env_t *env, uint32 virt, uint32 phys)
 { _Pf("P'lazy_paging_pfh");
uint32 new_phys;
        if (phys & PTE_LAZY)
         {
                new_phys= alloc4k(1,false);
                if ((new_phys==NULL)||(new_phys==0xffffffff))
                        { complain("insufficient memory!"); preturn( EFAIL ); }

                env->mtree->pte_map(virt&0xfffff000, new_phys|(phys-PTE_LAZY)|PTE_PRESENT|PTE_WRITEABLE|PTE_USER);
                preturn( ESUCCESS );
         }
        preturn( EFAIL);
 }

//alloc a memory space, yea
int allocate_memtree(class memtree *mtree, bool supervisor, class Memory::Heap::heapbox *hp)
 { _Pf("P'allocate_memtree");
uint32 *pgd;
void *dest, *src;
uint32 cnt;
//clear the data
        memset(mtree,0,sizeof(class memtree));
//create the page directory
        pgd= (uint32*)hp->malloc(4096, PAGE_ALIGN, FAC_MEMORY|FAC_PGD, NULL);
        memset(pgd,0,4096);

//copy the kernel level page directory entries
        dest= pgd+(mem_kernel_start/PGT_WIDE);
        src= Memory::Pager::kmem.page_directory+(mem_kernel_start/PGT_WIDE);
        cnt= 1024-(mem_kernel_start/PGT_WIDE);  //1024- the number of 4Mibs in the memspace
        memmove(dest,src,cnt*sizeof(uint32));
//intialise the data
        mtree->init(pgd, hp);
        mtree->cr3=Memory::Pager::kmem.pte_val((uint32)pgd)&0xfffff000;
//map the page directory into itself
        pgd[mem_pgd_start/PGT_WIDE]= mtree->cr3|PTE_PRESENT|PTE_WRITEABLE;

        preturn( ESUCCESS );
 }

/*==============address space paging*/
/*init to a given pgd data*/
void memtree::init(addr_t *pgd/*, bool supervisor*/, Memory::Heap::heapbox *hp)
 {
// setup
        page_directory=pgd;
// a memory map
        memory_map.init(mem_user_start, mem_user_end, hp);
// // flags
//      flags= 0;
//      if (!supervisor)
//              flags=PTE_USER;
 }

//done. does minor cleanup, does not destruct the memory_map or the heap
void memtree::done()
 {
// we do not need to even destroy the page_directory, because it is in the heapbox. the heapbox is destroyed seperately
 }

/*assign value to virt addr*/
void memtree::pte_map (addr_t virt, uint32 value)
 { _Pf("memtree::pte_map");
addr_t *page_table=(addr_t*) page_directory[virt>>22];
/*make sure there's a pde associated with this entry*/
        if (page_table == NULL)
                {page_directory[virt>>22]=alloc4k(1,true)|(value&PTE_MASK)|PTE_PRESENT|PTE_WRITEABLE;
                page_table=(addr_t*)page_directory[virt>>22];}

/*get rid of the attributes*/
        page_table=(addr_t*)((uint32)page_table & 0xFFFFF000);
        frame_assign((uint32)page_table);
/*now operate on the page table*/
        ((uint32*)virtual_frame)[(virt & 0x3fffff)>>12] = value;
        frame_release();

        invalidate (virt);

        preturn();
 }

/*get value assigned to virt addr*/
uint32 memtree::pte_val (addr_t virt)
 { _Pf("memtree::pte_val");
uint32 ret;

/* czasami wystepuje deadlock gdy pte_val jest odpalane z interrupt handlera
 * prawdopodobnie gdy inny watek zdazyl zablokowac
 * postaramy sie temu przeciwdzialac z cli*/
uint32 fl;
   asm volatile("pushf\npopl %0\ncli" : "=g" (fl));

        if (page_directory[virt>>22]==NULL)
                preturn (NULL);

        frame_assign(page_directory[virt>>22] & 0xfffff000);
        ret=((uint32*)virtual_frame)[(virt & 0x3fffff)>>12];
        frame_release();

   asm volatile("pushl %0\npopf" : : "g"(fl));

        preturn (ret);
 }

/*unassign a value from virt addr*/
void memtree::pte_umap (addr_t virt) {
        pte_map(virt, NULL);
 }

/*setup a page for lazy paging*/
void memtree::pte_lazy(addr_t virt, uint32 flags) {
        pte_map(virt, NULL | PTE_LAZY | flags);
 }

//alloc page or lazy, if enabled
int memtree::pte_alloc(addr_t virt, uint32 flags)
 {
addr_t r;
        if (lazy_enable)
                { pte_lazy(virt,flags); return ESUCCESS; }
        r= alloc4k(1,false);
        if ((r==NULL)||(r==0xffffffff)) return EINVAL;
        pte_map(virt, r|flags|PTE_PRESENT);

        return ESUCCESS;
 }

/*==============frame*/
/*assign an address to the frame page and lock this resource*/
void frame_assign (addr_t physical) {
        FrameAssign(virtual_frame, &lock_frame, physical);
 }

/*release the frame*/
void frame_release() {
        lock_frame.ulock();
 }

/*assign an address to the frame page and lock this resource*/
void FrameAssign (void *frame, class IPC::Lock::lock_t *l, addr_t physical)
 { _Pf("Pager::FrameAssign");
addr_t *PGT;
uint32 i;
        l->lock();

        /*we can do so because we have the pgd mapped into itself at pde 0x3fe.
        *variable_virt holds a virtual adress, which we will remap to our needs*/
        i = ((uint32)frame) >> 22;
        PGT = (addr_t*) (0xFF800000 + i * 0x1000);

        i = ((uint32) frame) & 0x3FFFFF;
        PGT[(uint32) i >> 12] = (addr_t)((uint32)physical + 3); /*supervisor space*/

        invalidate((addr_t)frame);
        preturn();
 }

/*release the frame*/
void FrameRelease(class IPC::Lock::lock_t *l) {
        l->ulock();
 }

// copy data from one physical page to another
void cpypage(uint32 dest, uint32 src)
 {_Pf("Memory::cpypage");
char buf[PAGE_SIZE];
// copy the data from one page
        frame_assign(src);
        memmove(buf,virtual_frame,PAGE_SIZE);
        frame_release();

// to another
        frame_assign(dest);
        memmove(virtual_frame, buf, PAGE_SIZE);
        frame_release();
        preturn();
 }

//copy data from one memspace to another
void memmove2(class memtree *d1, void *d2, class memtree *s1, void *s2, uint32 cnt)
 { _Pf("Pager::memmove2");
char *buf;
uint32 dest,src,ct,ct2=0;
        buf=(char*)Memory::Heap::heap0.malloc(cnt,NO_ALIGN,"memmove2 buf",NULL);

//copy from source
        if ((Thread::Scheduler::multitasking_running)&&(current_thread->proc->mem == s1))       //if the destination is in the current memory space, use memmove
                memmove(buf,s2,cnt); else {
        while (ct2<cnt)
         {
                src=(uint32)virtual_frame+(((uint32)s2+ct2)&0xfff);
                ct= MIN(0x1000-(((uint32)s2+ct2)&0xfff), cnt-ct2);
                dest= (uint32)buf+ct2;
                frame_assign(s1->pte_val(((uint32)s2+ct2)&0xfffff000)&0xfffff000);
                memmove((void*)dest,(void*)src,ct);
                frame_release();
                ct2+=ct;
         }/*while*/ }/*fi*/

//copy to dest
        if ((Thread::Scheduler::multitasking_running)&&(current_thread->proc->mem == d1))       //if the destination is in the current memory space, use memmove
                memmove(d2,buf,cnt); else {
        ct2=0;
        while (ct2<cnt)
         {
                src=(uint32)buf+ct2;
                dest=(uint32)virtual_frame+(((uint32)d2+ct2)&0xfff);
                ct= MIN(0x1000-(((uint32)d2+ct2)&0xfff), cnt-ct2);
                frame_assign(d1->pte_val(((uint32)d2+ct2)&0xfffff000)&0xfffff000);
                memmove((void*)dest,(void*)src,ct);
                frame_release();
                ct2+=ct;
         }/*while*/  }/*fi*/

        Memory::Heap::heap0.free(buf);
        preturn();
 }


// /*invalidate the virt's addr in the translation lookaside buffer*/
// void invalidate(addr_t virt) {
// /*first try*/
//      __asm__ __volatile__ ("mov %cr3, %eax\nmov %eax, %cr3");
//  }


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

/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---