src/module/mods.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                             *
************************************************************
*       mods.cpp, version 1.0                              *
************************************************************
*                                                          *
*This file handles the modules, which are given through    *
*grub.                                                     *
*                                                          *
*28'07'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/mboot.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/align.hpp"
#include "src/memory/pager.hpp"
#include "src/memory/heap.hpp"
#include "src/thread/thread.hpp"
#include "src/thread/scheduler.hpp"
#include "src/thread/process.hpp"
#include "src/module/elf.hpp"
#include "src/module/mods.hpp"

namespace Module {


void init()
 {
//      return ;
int i, mcnt= Mboot::mods_count();
uint32 x,n;
static class Memory::Pager::memtree *mtree;
class elf_t elf;
class Memory::Heap::heapbox *hp;
struct Mboot::mod_info *m;
struct Elf32_shdr *sect;
Thread::process_t *p;
bool supervisor;

//foreach $module
        for(i=0;i<mcnt;i++)
         {
                supervisor= false;
        //create a process object
                p= (Thread::process_t*)Memory::Heap::heap0.malloc(sizeof(Thread::process_t),NO_ALIGN,"proc",NULL);
                hp= &p->heap;
        //create a heap
                allocate_heapbox(hp, "proc");
        //create a memspace
                m= Mboot::mods_info(i);
                mtree= (class Memory::Pager::memtree*)hp->malloc(sizeof(class Memory::Pager::memtree), NO_ALIGN, "mtree", NULL);
                Memory::Pager::allocate_memtree(mtree, supervisor, hp);
        //init process object
                p->InitKeepHeap("p0", mtree);
        //page the module into the space
                elf.init((char*)m->mod_start,m->mod_end-m->mod_start);

        //find the bss sections
                for (x=0;x<elf.ehdr->e_shnum;x++)
                 {
                        if ((sect=elf.section(x))->sh_type!=SHT_NOBITS)
                                continue;
                //create the bss
                        if (sect->sh_size == 0)
                                continue;

                        if ((sect->sh_addr > mem_user_end)||
                                (sect->sh_addr+sect->sh_size > mem_user_end))
                                        { complain("elf: bss section to overlap kernel space"); break; }
                        for (n=sect->sh_addr;n<sect->sh_addr+sect->sh_size;n+=4096)
                                mtree->pte_map(n,alloc4k(1,true)|PTE_PRESENT|PTE_WRITEABLE|(supervisor?NULL:PTE_USER));
                 }
        //find the progbits sections
                for (x=0;x<elf.ehdr->e_shnum;x++)
                 {
                //head-hunt the progbits sects'
                        if ((sect=elf.section(x))->sh_type!=SHT_PROGBITS)
                                continue;
                //sanity
                        if (sect->sh_size == 0)
                                continue;
                        if (sect->sh_addr==0)//yea, such exist as well
                                continue;
                        if ((sect->sh_addr > mem_user_end)||
                                (sect->sh_addr+sect->sh_size > mem_user_end))
                                        { complain("progbits: section to overlap kernel space"); break; }
                        for (n=sect->sh_addr;n<sect->sh_addr+sect->sh_size;n+=4096)
                                if (mtree->pte_val(n)==NULL)
                                        mtree->pte_map(n,alloc4k(1,true)|PTE_PRESENT|PTE_WRITEABLE|(supervisor?NULL:PTE_USER));

                //copy the contents of the sections across memory spaces. well duh
                        memmove2(mtree, (void*)sect->sh_addr, &Memory::Pager::kmem, &elf.image[sect->sh_offset], sect->sh_size);
                 }
        //no more computations on the object.
                elf.done();

        //create first thread
                p->create_thread(supervisor, mem_exec, 10, 3, "user0"); //kernel processes. nice. that's what "kernel modules" are=)
                mtree->pte_map(0, 0xb8007);
        //register process
                ProcessRegister(p);
         }
 }


 };     /*namespace Module*/


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

---