src/memory/shmem.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                             *
************************************************************
*       shmem.cpp, version 1.0                             *
************************************************************
*                                                          *
*Shared memory buahaha                                     *
*                                                          *
*22'08'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/thread/process.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/memory/pager.hpp"
#include "src/memory/shmem.hpp"

namespace Memory {
namespace Shmem {

/* shared data must be page aligned and in page granulity. a virt page of memory of a memory space
  may not be shared by two shmem_t structs */

//create
int shmem_create(struct shmem_t *sh, class Memory::Pager::memtree *tree, uint32 virtaddr, uint32 size, bool cow, bool super)
 {
struct shmem_s s;
struct blist_s *b;
uint32 n;
//sanity
        if (virtaddr & 0xfff) return EINVAL;
        if (size & 0xfff) return EINVAL;
//setup object
        memset(sh, 0, sizeof(struct shmem_t));
        sh->li.init("shmem", &Memory::Heap::heap0);
        sh->cnt=1;
        sh->cows=(cow?1:0);
        sh->size=size;
        sh->super=super;
//add to the list
        memset(&s,0,sizeof(struct shmem_s));
        s.cow=cow;
        s.lgth=size;
        s.offset=0;
        s.sm=sh;
        s.virtaddr=virtaddr;
        s.tree=tree;
        b=sh->li.add((void*)&s,sizeof(struct shmem_s),NULL);
        if (b==NULL) sysfail("b=null");
//add to the memory map
        tree->memory_map.add(virtaddr, size, ME_SHMEM, b->data, /*info*/0, /*threadno*/0, &shmem_mapdone);
//copy the mappings to pgs
        sh->pgs= (uint32*)Memory::Heap::heap0.malloc(sizeof(uint32)*size/PAGE_SIZE, NO_ALIGN, 123, NULL);
uint32 i=0;
        for(n=0;n<size;n+=PAGE_SIZE)
         {
        uint32 ph;
                ph= tree->pte_val(virtaddr+n);
                sh->pgs[i]=ph;
                i++;
         }
//if copy-on-write, mark all pages as ro
        i=0;
        if (cow)
        for(n=0;n<size;n+=PAGE_SIZE)
         {
        uint32 ph,nph;
                nph=ph= sh->pgs[i];
                nph&=0xFFFFFFFF-PTE_WRITEABLE-PTE_USER; //clear user and rw flags
                nph|= super?0:PTE_USER; //setup user flag when needed
                nph|=PTE_SHMEM;//shared
                if (ph&PTE_PRESENT)
                        tree->pte_map(virtaddr+n, nph);
                i++;
         }

        return ESUCCESS;
 }

//done
int shmem_mapdone(mmap_t *mpt, mmap_s *mps)
 {
        notimpl(-1);
 }

//attach to a shared object
int shmem_attach(struct shmem_t *sh, class Memory::Pager::memtree *tree, uint32 virtaddr, uint32 offset, uint32 lgth, bool cow)
 {
struct shmem_s shm;
struct blist_s *b;
uint32 n;
//fix up counts in the shmem_t struct
        sh->cnt++;
        if (cow) sh->cows++;
//for copy-on-write, map all copies of the data ro for page fault handling @rw access
        if (cow)        //if this is copy-on-write
        if (sh->cows == 1)      //if this is the first copy-on-write
                shmem_roall(sh);
//map the pages as read-only, not-present with the mappings from cache
uint32 i=offset/PAGE_SIZE;
        for (n=0;n<lgth;n+=PAGE_SIZE)
         {
        uint32 ph;
                ph= sh->pgs[i];
                cout(ph);cout(const_cast<char*>("|"));
                if (ph & PTE_PRESENT)   //map
                        tree->pte_map(virtaddr+n, (ph&0xfffff000)|(sh->super?0:PTE_USER)|PTE_SHMEM|((sh->cows||cow)?PTE_RO:PTE_WRITEABLE)|PTE_PRESENT); //non-present, read-only, user/supervisor, shared
                else
                        tree->pte_map(virtaddr+n, ph);  //for all the non-present pages like lazy
                i++;
         }
//add to the shmem_t
        memset(&shm,0,sizeof(struct shmem_s));
        shm.sm=sh;
        shm.tree=tree;
        shm.cow=cow;
        shm.offset=offset;
        shm.virtaddr=virtaddr;
        shm.lgth=lgth;
        b=sh->li.add((void*)&shm, sizeof(struct shmem_s), NULL);
        if (b==NULL) sysfail("b==NULL2");
//add to memory_map
        tree->memory_map.add(virtaddr, lgth, ME_SHMEM, b->data, /*info*/0, /*threadno*/0, &shmem_mapdone);

        return ESUCCESS;
 }

//map all present pages of the copies as ro
int shmem_roall(struct shmem_t *sh)
 {
blist_s *item;
struct shmem_s *sm;
uint32 n;
        for (item=sh->li.head;item;item=item->next)
         {
                sm= bli_dt(item,struct shmem_s*);
                for (n=0;n<sm->lgth;n+=PAGE_SIZE)
                 {
                uint32 ph, nph;
                        nph=ph= sm->tree->pte_val(sm->virtaddr+n);
                        if (!(ph & PTE_PRESENT)) continue;
                        if (!(ph & PTE_WRITEABLE)) continue;
                        nph&=0xffffffff-PTE_WRITEABLE;
                        sm->tree->pte_map(sm->virtaddr+n, nph);
                 }
         }

        return ESUCCESS;
 }

//map
int shmem_map(struct shmem_s *sh)
 {
uint32 n;
        for (n=0; n<sh->lgth; n+=PAGE_SIZE)
        //map the shared area as non-present, shared
                sh->tree->pte_map(sh->virtaddr+n,NULL|PTE_SHMEM|(sh->sm->super?0:PTE_USER));
        return ESUCCESS;
 }

  };    /*namespace Shmem*/
 };     /*namespace Memory*/

// shared memory page fault handler
int shmem_paging_pfh(struct env_t *en, uint32 virt, uint32 phys)
 {
struct Memory::Shmem::shmem_s *shs;
struct Memory::Shmem::shmem_s *sh2;
struct Memory::Shmem::shmem_t *sht;
uint32 ofs;
//sanity
        if (!(phys & PTE_SHMEM)) return EINVAL;

//get the shmem_s
struct blist_s *item;
        if (en->mtree==NULL) sysfail("en->tree==NULL");
        item= en->mtree->memory_map.mmap_find(ME_SHMEM, virt);
        if (item==NULL) return EFAIL;
        shs= (struct Memory::Shmem::shmem_s*)bli_dt(item,struct mmap_s*)->dt;
//get the shmem_t
        sht= shs->sm;
//count the offset in the data
        ofs= (virt&0xfffff000)-shs->virtaddr+shs->offset;

//check the problem- non-present pf or write pf for copy-on-write data?
        if (phys & PTE_PRESENT)
        //copy-on-write write access
         {
                if (shs->cow)
                 {
                //request for a cow copy
                uint32 ph= alloc4k(1,false);
                        if (ph==0) { complain("shmem_paging_pfh: cow: insufficient memory!"); return EFAIL; }
                //alloc the new page
                        en->mtree->pte_map(virt&0xfffff000, ph|(sht->super?0:PTE_USER)|PTE_WRITEABLE|PTE_PRESENT|PTE_SHMEM);
                //copy the data from the first copy of the data
                        Memory::Pager::cpypage(ph, sht->pgs[ofs/PAGE_SIZE]&0xfffff000);
//                      sh2= bli_dt(sht->li.head,struct Memory::Shmem::shmem_s*);
//                      memmove2(current_thread->proc->mem, (void*)(virt&0xfffff000),
//                              sh2->tree, (void*)(sh2->virtaddr+ofs),
//                                      PAGE_SIZE);
                 } else 
                  {
                 //this memory space requires to have a shared copy, but some other require cow access
                struct blist_s *item;
                        for (item=sht->li.head;item;item=item->next)
                         {
                        //is this page in this copy?
                        sh2= bli_dt(item,struct Memory::Shmem::shmem_s*);
                        if ((sh2->offset > ofs)||(sh2->offset+sh2->lgth)<ofs) continue;
                        //is this copy cow?
                        if (!sh2->cow) continue;
                        //alloc a new page
                uint32 ph= alloc4k(1,false);
                        if (ph==0) { complain("shmem_paging_pfh: cow: insufficient memory!"); return EFAIL; }
                        //copy data
                        Memory::Pager::cpypage(ph,phys&0xfffff000);
                        sh2->tree->pte_map(sh2->virtaddr+ofs-sh2->offset, ph|PTE_PRESENT|PTE_WRITEABLE|(sht->super?0:PTE_USER)|PTE_SHMEM);
                         }      /*fi shs->cow*/
                //map the faulty page as writeable
                        en->mtree->pte_map(virt&0xfffff000, phys|PTE_WRITEABLE);
                  }     /*fi phys&PTE_PRESENT*/
         } else
        //page not present
          {
                if (phys&PTE_LAZY)
                 {      //alloc a page for all the copies
                uint32 new_phys;
                struct blist_s *item;
                        new_phys= alloc4k(1,false);
                        if ((new_phys==NULL)||(new_phys==0xffffffff))
                                { complain("shmem_paging_pfh: insufficient memory!"); return EFAIL; }
                //save the mapping into the cache
                        sht->pgs[ofs/PAGE_SIZE]=new_phys|PTE_PRESENT;
                //copy the mapping to all copies
                        for (item=sht->li.head;item;item=item->next)
                         {
                        sh2= bli_dt(item,struct Memory::Shmem::shmem_s*);
                        if ((sh2->offset <= ofs)&&(sh2->offset+sh2->lgth)>ofs)
                        sh2->tree->pte_map(sh2->virtaddr+ofs-sh2->offset, new_phys|PTE_PRESENT|((sht->cows||shs->cow)?PTE_RO:PTE_WRITEABLE)|(sht->super?0:PTE_USER)|PTE_SHMEM);
                         }
                 } else
                  {     //copy the mapping from the first sopy
                        write_bochs("e");
                 uint32 ph;
//                      sh2= bli_dt(sht->li.head,struct Memory::Shmem::shmem_s*);
                        write_bochs("h");
//                      ph= sh2->tree->pte_val(shs->offset+sh2->virtaddr);
                        ph= sht->pgs[ofs/PAGE_SIZE];
                        ph&=0xfffff000;
                        ph|=PTE_SHMEM|PTE_PRESENT|((sht->cows||shs->cow)?PTE_RO:PTE_WRITEABLE)|(sht->super?0:PTE_USER);
                        write_bochs("i");
//                      if (sht->cows && (ph&PTE_WRITEABLE))    //this means, that the page is shared cow and forked for the first copy
//                              sysfail("non-writeable page in first copy");
                        write_bochs("j");
//                              ph&=0xffffffff-PTE_WRITEABLE;   //then ro it
                        shs->tree->pte_map(virt&0xfffff000, ph);
                        write_bochs("g");
                  }
          }

        return ESUCCESS;
 }


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

---