src/module/api1.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                             *
************************************************************
*       api1.cpp, version 1.0                              *
************************************************************
*                                                          *
*The first panalix API                                     *
*                                                          *
*28'07'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/heap.hpp"
#include "src/ipc/msg.hpp"
#include "src/thread/process.hpp"
#include "src/thread/scheduler.hpp"
#include "src/module/api1.hpp"

namespace API {
namespace v1 {

//checks whether the whole object is in kernel space
bool isKernelSpace(uint32 addr, uint32 size)
 {
        return (addr >= mem_kernel_start) ||    //it begins in kernel space
                (size > 0xffffffff-addr+1) ||   //it begins in user space, partly in kernel space, wraps over the 33bit
                (addr+size > mem_kernel_start); //begins in user space, ends in kernel space
 }

int req(struct env_t *env, int *args)
 {
int i;
// uint32 n,x;
// struct Thread::thread_t *thread;
// struct blist_s *bl;
// struct mmap_s *mmaps;
// struct IPC::Message::message *msg;
        i=0;
//sanity
        if ((args==NULL)||(env==NULL)||(env->code==NULL)||(env->thread==NULL)||(Thread::Scheduler::multitasking_running==false))
                return ESANITY;

        switch(env->code->r.r_eax)
         {
// API- send a message to thread args[0] of process %ebx, from user-level data starting at args[1] of size args[2] with flags of args[3]. returns EFAIL if data is in kernel space or the dest thread is not found.
//      case API_SENDMSG:
//      //sanity
//              if (isKernelSpace(args[2], args[3]))
//                      return EFAIL;
//      //findout receiver
//              thread= Thread::ThreadGet(env->code->r.r_ebx, args[0]);
//              if (thread==NULL)
//                      return EFAIL;
//              return env->thread->inbox.ksend(&thread->inbox, (void*)args[1], args[2], args[3]);

// API- recv a message, recv a message from a specified mailbox or return count of incoming messages.
// %ebx=1 recv, %ebx=2 recv src, %ebx=3 count.
// recv: return: args[0] with address to the message struct.
        case API_RECVMSG:
        // receive the message
        // allocate space in the user space for the data
        // copy the message
        // dispose the message from the original heap (a copy in the user space exists)
        // return
//              if (env->code->r.r_ebx==1)
//               {
//                      i= env->thread->inbox.kreceive(&msg);
//                      if (i!=ESUCCESS) return i;
//                      i= env->mtree->memory_map.fitbelow(sizeof(msg)+msg->size, PAGE_ALIGN, mem_user_end+1, ME_USERDATA, NULL,0/*info*/, &n, 0/*threadno*/, NULL/*destroy*/, false);
//                      if (i!=ESUCCESS) {ThreadFail("dropped message"); return i; }
//                      for (x=0;x<msg->size+sizeof(msg);x+=PAGE_SIZE)
//                              env->mtree->pte_alloc(x+n,PTE_WRITEABLE|PTE_USER);
//                      memmove((void*)n, msg, sizeof(IPC::Message::message)+msg->size);
//                      env->thread->inbox.free_msg(msg);
//                      args[0]=n;
//                      alert("\n");alert(n);
//                      return ESUCCESS;
//               }
//              return EFAIL;
// API- unalloc the space given with the message; %ebx is the address
/*      case API_FREEMSG:
                bl= env->mtree->memory_map.find(env->code->r.r_ebx);
                if (bl==NULL) return EFAIL;
                mmaps= bli_dt(bl,struct mmap_s*);
                if (mmaps->type != ME_USERDATA) return EINVAL;
                for(n=0;n<mmaps->size;n+=PAGE_SIZE)
                 {
                        x= env->mtree->pte_val(n+env->code->r.r_ebx);
                        if (x&PTE_PRESENT)
                                disalloc4k(x&0xfffff000);
                        env->mtree->pte_umap(n+env->code->r.r_ebx);
                 }
                env->mtree->memory_map.del(bl);
                return ESUCCESS;*/
// API- cout a given text to std output
        case API_COUT:
                cout((char*)args[0]);
                return ESUCCESS;
// API- get the process & thread no
        case API_GETPROCNO:
                args[0]= env->proc->no;
                args[1]= env->thread->no;
                return ESUCCESS;
// API- sleep thread
        case API_SLEEP:
                return Thread::sleep(*(uint64*)&args[0]);
// API- morecore
        case API_MORECORE:
                args[0]=user_morecore(env, args[0]);
                return ESUCCESS;
         }

        return EINVAL;
 }


//allocate some virtual space for the process, and lazy it
uint32 user_morecore(struct env_t *env, uint32 cnt)
 {
int i;
uint32 n;
uint32 loc;
//allocate virtual memory in the process's user space
        i= env->mtree->memory_map.fitbelow(cnt*PAGE_SIZE, PAGE_ALIGN, mem_user_end+1, ME_UDATA, NULL/*dt*/, 0/*info*/, &loc, 0, &UDATA_destroy, false);
        if (i!=ESUCCESS) return NULL;
//now allocate physical memory to it; if possible, use demand-paging
        for (n=0;n<cnt;n++) {
                i= env->mtree->pte_alloc(loc+n*PAGE_SIZE, PTE_WRITEABLE);
                if (i!=ESUCCESS) { complain("!!fail and memory not regained"); return i; }
                }

        return loc;
 }

//destroys the UDATA alloced for the process
int UDATA_destroy(mmap_t *mt, mmap_s *ms)
 {
        notimpl(-1);
 }

  };    /*namespace v1*/
 };     /*namespace API*/


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

---