bsb2/kernel/syscall/skeleton.cc

#include "../syscall/skeleton.h"

#include "../debug/kernelpanic.h"
#include "../debug/output.h"
#include "../device/textstream.h"
#include "../interrupt/guard.h"
#include "../sync/semaphore.h"
#include "../thread/scheduler.h"
#include "../memory/pageframealloc.h"
void *operator new(size_t, void *);

//#include "../user/app1/appl.h"
//extern Application apps[];

uint8_t mapNumber = 0;

namespace Syscall {
  namespace Skeleton {


    void invlpg(uintptr_t virt_addr) {                                                                                                                                                           
      asm volatile("invlpg (%0)" : : "r" (virt_addr) : "memory");                                                                                                                                           
    }   

    size_t test(Vault &vault, size_t p1, size_t p2, size_t p3, size_t p4,
        size_t p5) {
      (void)vault;
      vault.kout << "test(" << p1 << ", " << p2 << ", " << p3 << ", " << p4
        << ", " << p5 << ");" << endl;
      return 0xdeadbeef;
    }

    int getpid(Vault &vault) {
      Thread *me = vault.scheduler.active();
      //unsigned id = 0;
      //while (&apps[id++] != me); // TODO find better pid source
      //return id;
      return me->id;
    }

    size_t write(Vault &vault, uint32_t id, const void *buffer, size_t size, int x, int y) {
      (void)id;

      TextStream* out;

      switch (id) {
        case 1:
          out = &vault.kout;
          break;
        case 2:
          out = &dout;
          break;
        default:
          out = &vault.kout;
      }

      int dummy;
      if(x == -1 && y != -1)
        out->getPos(x, dummy);
      if(x != -1 && y == -1)
        out->getPos(dummy, y);
      if(x == -1 && y == -1)
        out->getPos(x, y);

      out->setPos(x, y);

      for(size_t i = 0; i<size; i++)
        *out << ((char*)buffer)[i];
      out->flush();

      return 0;
    }

    size_t read(Vault &vault, uint32_t id, void *buf, size_t len) {
      (void)id;

      size_t read_cnt = 0;
      while(read_cnt < len){
        Key key;
        vault.keys_sem.p(vault);
        vault.keys.consume(key);
        if(key.valid())
          ((char*)buf)[read_cnt++] = key.ascii();
        else
          break;
      }
      return read_cnt;
    }

    void sleep(Vault &vault, size_t ms) {
      vault.bellringer.sleep(vault, ms);
    }

    bool sem_init(Vault &vault, size_t id, uint32_t value) {
      if (id >= vault.MAX_SEMS) {
        return false;             // out‐of‐range id
      }
      if (vault.sems[id].used==1){
        return false;  //already in use
      }

      vault.sems[id].counter=value;
      return true;
    }

    bool sem_destroy(Vault &vault, size_t id) {
      if (id >= vault.MAX_SEMS) {
        return false;             // out‐of‐range id
      }
      if (vault.sems[id].used==0){
        return false;  //already in free
      }

      vault.sems[id].used=0;
      vault.sems[id].counter=0;
      return true;
    }

    bool sem_signal(Vault &vault, size_t id) {
      vault.sems[id].v(vault);

      return true;
    }

    bool sem_wait(Vault &vault, size_t id) {
      vault.sems[id].p(vault);
      return true;
    }

    void exit(Vault &vault) {
      vault.scheduler.exit();
    }

    void kill(Vault &vault, size_t pid){
      //vault.scheduler.kill(&apps[pid]);
    }



    void* getFreeVirtSpace(Vault* vault, uint8_t num_pages){
      pagetable_t* subbytable = vault->scheduler.active()->subtable;
      //uint32_t page_counter=0;
      for (uint32_t v=0x4000; v<0x4200; v++) { 
        bool space_is_free = true;
        for(uint32_t i=0; i<num_pages; i++){
          if(subbytable->entries[v-0x4000+i].present) {
            space_is_free = false;
          }  
        }
        if(space_is_free)
          return  (void*) ((uintptr_t) (v <<12));
      }
      return 0;

  }

    void* map(Vault *vault, size_t size) {
      size_t num_pages = (size + 4096 - 1) / 4096;
      pagetable_t* subbytable = vault->scheduler.active()->subtable;

      void* ptr = getFreeVirtSpace(vault, num_pages);
      if (ptr == nullptr) {
        return nullptr;
      }
      uintptr_t gap_start = reinterpret_cast<uintptr_t>(ptr);

      // map all used pages
      for (size_t i = 0; i < num_pages; ++i) {
        // allocate each page with allocator	
        void* frame = PageFrameAllocator::alloc(false);

        subbytable->entries[(( (uintptr_t) frame-64*1024*1024) /4096)] ={
          .present = 1,
          .write =1,
          .user =1,
          .address = i+((uintptr_t) ptr >> 12) 
        };

      }
      return ptr;
    }

    int unmap(Vault &vault, void* start, size_t size) {  
      uint32_t NumberOfPages = (size/4096);
      pagetable_t* subbytable = vault.scheduler.active()->subtable;
      uint32_t startIndex = (((uintptr_t)start-64*1024*1024)>>12);  
      memset(start, 0, size);

      for(uint32_t i=startIndex; i<(startIndex+NumberOfPages); i++){
        for (uint32_t p =0; p<512 ; p++) {
          if (subbytable->entries[p].present==1 && subbytable->entries[p].address==i) { 
            invlpg(i);
            subbytable->entries[i].present =0;
          }
        }
      }
      return 0; 
    }
  }  // namespace Skeleton
}  // namespace Syscall