src/thread/process.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                             *
************************************************************
*       process.cpp, version 1.0                           *
************************************************************
*                                                          *
*here we define basic operations and datatypes needed to   *
*manage processes.                                         *
*                                                          *
*02'15'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/string.hpp"
#include "src/common/blist.hpp"
#include "src/common/blistsort.hpp"
#include "src/common/qsort.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/heap.hpp"
#include "src/memory/pager.hpp"
#include "src/arch/x86/context.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/thread/scheduler.hpp"
#include "src/thread/process.hpp"

inline void *kmalloc (size_t size, size_t alignment, uint32 facility, int (*destruct)(class Memory::Heap::heapbox*,void*))
 {
        return Memory::Heap::heap0.malloc(size,alignment,facility,destruct);
 }

inline int kfree(void *ptr)
 {
        return Memory::Heap::heap0.free(ptr);
 }

//get current env info
int EnvGet(struct env_t *env)
 {
        memset(env,0,sizeof(struct env_t));
        if (Thread::Scheduler::multitasking_running) {
                env->thread= (Thread::thread_t*)current_thread;
                env->proc= current_thread->proc;
                env->mtree= env->proc->mem;
                env->code= env->thread->env.cd;
        } else {
                env->mtree= &Memory::Pager::kmem;
        }

        return ESUCCESS;
 }

namespace Thread {


//variables
process_t kernel_process;       //the kernel process
class blist_t Processes;        //the list of processes in system

int LastProcessNum= 1;

//add a process to the list
int ProcessRegister(class process_t *proc)
 {
        proc->no= LastProcessNum++;
        Processes.ptr(proc, NULL);

        return proc->no;
 }

//kill a process by killing all it's threads
int ProcessKill(int no)
 {
process_t *proc;
        proc= ProcessGet(no);
        if (proc == NULL) return EFAIL;

blist_s *item;
bool b=false;
        for(item=proc->thread_list.head;item;item=item->next)
                if (bli_dt(item,thread_t*)!=current_thread) ThreadKill(bli_dt(item,thread_t*));
                        else b=true;

        if (b) ThreadKill((Thread::thread_t*)current_thread);
        return ESUCCESS;
 }

//grab a process' struct knowing it's num
process_t *ProcessGet(int i)
 {
blist_s *item;
        for (item=Processes.head;item && (bli_dt(item,process_t*)->no <= i) ;item=item->next)
                if (bli_dt(item,process_t*)->no == i) return bli_dt(item,process_t*);
        return NULL;
 }

//init
void process_t::init(char *nam, Memory::Pager::memtree *mtree)
 {
//clear
        memset(this,0,sizeof(process_t));
//init vars
        mem= mtree;
        memmove(&name, nam, ( lgth(nam)<PROC_NAME-1 )? lgth(nam): PROC_NAME-1);
        thread_list.init(FAC_THREAD|FAC_THRLIST);
        allocate_heapbox(&heap, name);
 }

//init
void process_t::InitKeepHeap(const char *nam, Memory::Pager::memtree *mtree)
 {
Memory::Heap::heapbox hp;
//clear
        memmove(&hp, &heap, sizeof(hp));
        memset(this,0,sizeof(process_t));
        memmove(&heap, &hp, sizeof(hp));
//init vars
        mem= mtree;
        memmove(&name, nam, ( lgth(nam)<PROC_NAME-1 )? lgth(nam): PROC_NAME-1);
        thread_list.init(FAC_THREAD|FAC_THRLIST);
 }

//create a new thread
thread_t *process_t::create_thread(bool supervisor, uint32 proc_addr, uint32 worst_priority, uint32 best_priority,
                const char name[])
 {
// ** priorities are not respected. this is a round-robin scheduler right now
   best_priority = 0;
   worst_priority = 0;


thread_t new_thread;
uint32 stack;
        memset(&new_thread, 0, sizeof(thread_t));
   // ** check for going over the counter
        new_thread.no= ++max_thread_no; //yea, no thread gets a zero threadno

        stack= alloc_stack(supervisor, 0x2000, new_thread.no);
        if (stack == NULL)
         {
                complain("alloc_stack failed");
                return NULL; };
//init some data
        new_thread.state=TH_ACTIVE;
        new_thread.creation_time=Arch::x86::RTC::up_time;
        new_thread.proc=this;
        allocate_context(&new_thread, supervisor, stack, proc_addr);
        new_thread.priority= MIN(DEF_THREAD_PRIOR,worst_priority);
        new_thread.worst_priority=worst_priority;
        new_thread.best_priority=best_priority;
uint32 cnt = lgth(const_cast<char*>(name)) < THREAD_NAME-1 ? lgth(const_cast<char*>(name)) : THREAD_NAME-1;
        memmove(&new_thread.name, const_cast<char*>(name), cnt);
//copy the structure into the process' heapbox
thread_t *thr;
        thr=(thread_t*) 
                thread_list.add(&new_thread, sizeof(thread_t), NULL)->data;
        allocate_mailbox(&thr->inbox, thr, &heap);
//add to the thread queues
        Thread::enqueue_thread(thr, &Thread::threads_queue[thr->priority]);

        return thr;
 }

int MmapDestroyStack(class mmap_t *m, struct mmap_s *s)
 {
process_t *proc;
uint32 i,addr;
        proc=(process_t*) (uint32) s->info;
        for (i=s->start;i<s->end; i+=PAGE_SIZE) {
                addr= proc->mem->pte_val(i);
                if (addr & PTE_PRESENT)         //simple rule, ain't it?
//              ;
                        disalloc4k(addr&0xfffff000);
         }

        return ESUCCESS;
 }

//allocate a stack
uint32 process_t::alloc_stack(bool supervisor, size_t size, uint32 threadno)
 {
//kernel stack
        if (supervisor)
                return size + (uint32) heap.malloc(size, PAGE_ALIGN, "kernel thread heap", NULL);
//user stack
uint32 addr;
int i;
        i= mem->memory_map.fitbelow(size, PAGE_ALIGN, mem_user_end+1, ME_STACK, NULL, (uint32)this, &addr, threadno, &MmapDestroyStack, false);
        if (i!= ESUCCESS)
                return NULL;
// map pages
uint32 n;
        for (n=addr; n<addr+size;n+=PAGE_SIZE)
                if (Memory::Pager::lazy_enable)
                        mem->pte_lazy(n, PTE_USER|PTE_WRITEABLE);
                else
                        mem->pte_map(n, alloc4k(1,false)|PTE_WRITEABLE|PTE_USER|PTE_PRESENT);

        return addr+size;
 }


 };     /*namespace Thread*/

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

---