lib/mammoth/src/process.cpp

@@ -71,9 +71,8 @@ uint64_t LoadElfProgram(uint64_t base, uint64_t as_cap) {
 #if MAM_PROC_DEBUG
     dbgln("Create mem object");
 #endif
-    uint64_t page_offset = program.vaddr & 0xFFF;
     uint64_t mem_cap;
-    uint64_t size = page_offset + program.memsz;
+    uint64_t size = program.memsz;
     check(ZMemoryObjectCreate(size, &mem_cap));
 
 #if MAM_PROC_DEBUG
@@ -81,21 +80,16 @@ uint64_t LoadElfProgram(uint64_t base, uint64_t as_cap) {
 #endif
     uint64_t vaddr;
     check(ZAddressSpaceMap(gSelfVmasCap, 0, mem_cap, &vaddr));
-    uint8_t* offset = reinterpret_cast<uint8_t*>(vaddr);
-    for (uint64_t j = 0; j < size; j++) {
-      offset[j] = 0;
-    }
 
 #if MAM_PROC_DEBUG
     dbgln("Copy");
 #endif
-    memcpy(base + program.offset, program.filesz, vaddr + page_offset);
+    memcpy(base + program.offset, program.filesz, vaddr);
 
 #if MAM_PROC_DEBUG
     dbgln("Map Foreign");
 #endif
-    check(
-        ZAddressSpaceMap(as_cap, program.vaddr - page_offset, mem_cap, &vaddr));
+    check(ZAddressSpaceMap(as_cap, program.vaddr, mem_cap, &vaddr));
   }
   return header->entry;
 }

sys/denali/ahci/ahci_driver.cpp

@@ -203,7 +203,6 @@ glcr::ErrorCode AhciDriver::LoadHbaRegisters() {
 glcr::ErrorCode AhciDriver::LoadDevices() {
   for (uint8_t i = 0; i < 32; i++) {
     if (!(ahci_hba_->port_implemented & (1 << i))) {
-      devices_[i] = nullptr;
       continue;
     }
     uint64_t port_addr =

sys/yellowstone/yellowstone.cpp

@@ -13,8 +13,9 @@
 #include "yellowstone_server.h"
 
 glcr::ErrorCode SpawnProcess(z_cap_t vmmo_cap, z_cap_t yellowstone_cap) {
-  OwnedMemoryRegion region = OwnedMemoryRegion::FromCapability(vmmo_cap);
-  return SpawnProcessFromElfRegion(region.vaddr(), yellowstone_cap);
+  uint64_t vaddr;
+  RET_ERR(ZAddressSpaceMap(gSelfVmasCap, 0, vmmo_cap, &vaddr));
+  return SpawnProcessFromElfRegion(vaddr, yellowstone_cap);
 }
 
 uint64_t main(uint64_t port_cap) {

zion/lib/memory_mapping_tree.cpp

@@ -55,6 +55,9 @@ glcr::ErrorCode MemoryMappingTree::FreeMemoryRange(uint64_t vaddr_base,
 
   auto find_or = mapping_tree_.Find(vaddr_base);
   if (find_or) {
+    dbgln("Mem addr {x} refcnt {}",
+          (uint64_t)find_or.value().get().mem_object.get(),
+          find_or.value().get().mem_object->ref_count());
     mapping_tree_.Delete(vaddr_base);
   }
   while (true) {

zion/loader/init_loader.cpp

@@ -130,8 +130,8 @@ void WriteInitProgram(glcr::RefPtr<Port> port, glcr::String name, uint64_t id) {
 
 glcr::ErrorCode WritePciVmmo(glcr::RefPtr<Port> port, uint64_t id) {
   ASSIGN_OR_RETURN(PcieConfiguration config, GetPciExtendedConfiguration());
-  auto vmmo = glcr::MakeRefCounted<FixedMemoryObject>(config.base,
-                                                      config.offset, false);
+  auto vmmo =
+      glcr::MakeRefCounted<FixedMemoryObject>(config.base, config.offset);
 
   port->WriteKernel(id, MakeRefCounted<Capability>(vmmo));
 

zion/memory/physical_memory.cpp

@@ -4,7 +4,6 @@
 
 #include "boot/boot_info.h"
 #include "debug/debug.h"
-#include "memory/constants.h"
 
 #define K_PHYS_DEBUG 0
 
@@ -50,7 +49,7 @@ class PhysicalMemoryManager {
 #endif
           size -= bootstrap_used;
         }
-        AddMemoryRegion(base, size / kPageSize);
+        AddMemoryRegion(base, size);
       }
     }
   }
@@ -66,7 +65,7 @@ class PhysicalMemoryManager {
 
     MemBlock& block = memory_blocks.PeekFront();
     uint64_t page = block.base;
-    block.base += kPageSize;
+    block.base += 0x1000;
     block.num_pages--;
     if (block.num_pages == 0) {
       memory_blocks.PopFront();
@@ -98,7 +97,7 @@ class PhysicalMemoryManager {
     }
 
     uint64_t page = iter->base;
-    iter->base += num_pages * kPageSize;
+    iter->base += num_pages * 0x1000;
     iter->num_pages -= num_pages;
 #if K_PHYS_DEBUG
     dbgln("Continuous {x}:{}", page, num_pages);
@@ -106,17 +105,11 @@ class PhysicalMemoryManager {
     allocated_pages_ += num_pages;
     return page;
   }
-
   void FreePage(uint64_t page) {
-    AddMemoryRegion(page, 1);
+    AddMemoryRegion(page, 0x1000);
     allocated_pages_--;
   }
 
-  void FreePages(uint64_t page, uint64_t num_pages) {
-    AddMemoryRegion(page, num_pages);
-    allocated_pages_ -= num_pages;
-  }
-
   uint64_t AllocatedPages() { return allocated_pages_; }
 
   uint64_t AvailablePages() {
@@ -137,10 +130,10 @@ class PhysicalMemoryManager {
 
   uint64_t allocated_pages_ = 0;
 
-  void AddMemoryRegion(uint64_t base, uint64_t num_pages) {
+  void AddMemoryRegion(uint64_t base, uint64_t size) {
     MemBlock block{
         .base = base,
-        .num_pages = num_pages,
+        .num_pages = size >> 12,
     };
     memory_blocks.PushFront(block);
   }
@@ -239,22 +232,8 @@ uint64_t AllocateContinuous(uint64_t num_continuous) {
   return gPmm->AllocateContinuous(num_continuous);
 }
 
-void FreePage(uint64_t page) {
-  if (gPmm == nullptr) {
-    panic("No physical memory manager!");
-  }
-  gPmm->FreePage(page);
-}
-
-void FreePages(uint64_t page, uint64_t num_pages) {
-  if (gPmm == nullptr) {
-    panic("No physical memory manager!");
-  }
-  gPmm->FreePages(page, num_pages);
-}
-
 void DumpPhysicalMemoryUsage() {
-  dbgln("Pages used: {} KiB, avail: {} MiB", gPmm->AllocatedPages() * 4,
+  dbgln("Pages used: {} MiB, avail: {} MiB", gPmm->AllocatedPages() / 256,
         gPmm->AvailablePages() / 256);
 }
 

zion/memory/physical_memory.h

@@ -19,9 +19,7 @@ uint64_t AllocatePage();
 uint64_t AllocateAndZeroPage();
 
 uint64_t AllocateContinuous(uint64_t num_pages);
-
 void FreePage(uint64_t page);
-void FreePages(uint64_t page, uint64_t num_pages);
 
 void DumpPhysicalMemoryUsage();
 

zion/object/address_space.cpp

@@ -14,7 +14,7 @@ glcr::RefPtr<AddressSpace> AddressSpace::ForRoot() {
 }
 
 AddressSpace::AddressSpace() {
-  cr3_ = phys_mem::AllocateAndZeroPage();
+  cr3_ = phys_mem::AllocatePage();
   InitializePml4(cr3_);
 }
 

zion/object/memory_object.cpp

@@ -20,13 +20,7 @@ MemoryObject::MemoryObject(uint64_t size) : size_(size) {
   }
 }
 
-MemoryObject::~MemoryObject() {
-  for (uint64_t page : phys_page_list_) {
-    if (page != 0) {
-      phys_mem::FreePage(page);
-    }
-  }
-}
+MemoryObject::~MemoryObject() { dbgln("Memory Object Freed"); }
 
 uint64_t MemoryObject::PhysicalPageAtOffset(uint64_t offset) {
   if (offset > size_) {
@@ -76,12 +70,6 @@ uint64_t MemoryObject::PageNumberToPhysAddr(uint64_t page_num) {
   return *iter;
 }
 
-FixedMemoryObject::~FixedMemoryObject() {
-  if (should_free_) {
-    phys_mem::FreePages(physical_addr_, num_pages());
-  }
-}
-
 glcr::ErrorOr<glcr::RefPtr<MemoryObject>> FixedMemoryObject::Duplicate(
     uint64_t offset, uint64_t length) {
   if (offset + length > size()) {
@@ -89,6 +77,5 @@ glcr::ErrorOr<glcr::RefPtr<MemoryObject>> FixedMemoryObject::Duplicate(
   }
 
   return glcr::StaticCastRefPtr<MemoryObject>(
-      glcr::MakeRefCounted<FixedMemoryObject>(physical_addr_ + offset, length,
-                                              false));
+      glcr::MakeRefCounted<FixedMemoryObject>(physical_addr_ + offset, length));
 }

zion/object/memory_object.h

@@ -31,7 +31,7 @@ class MemoryObject : public KernelObject {
   ~MemoryObject();
 
   uint64_t size() { return size_; }
-  uint64_t num_pages() { return ((size_ - 1) / 0x1000) + 1; }
+  uint64_t num_pages() { return size_ / 0x1000; }
 
   uint64_t PhysicalPageAtOffset(uint64_t offset);
 
@@ -58,20 +58,14 @@ class MemoryObject : public KernelObject {
 class FixedMemoryObject : public MemoryObject {
  public:
   // FIXME: Validate that this is 4k aligned.
-  // Create a new class object for should free.
-  FixedMemoryObject(uint64_t physical_addr, uint64_t size, bool should_free)
-      : MemoryObject(size, true),
-        physical_addr_(physical_addr),
-        should_free_(should_free) {}
-
-  ~FixedMemoryObject();
+  FixedMemoryObject(uint64_t physical_addr, uint64_t size)
+      : MemoryObject(size, true), physical_addr_(physical_addr) {}
 
   virtual glcr::ErrorOr<glcr::RefPtr<MemoryObject>> Duplicate(
       uint64_t offset, uint64_t length) override;
 
  private:
   uint64_t physical_addr_;
-  bool should_free_;
 
   uint64_t PageNumberToPhysAddr(uint64_t page_num) override {
     return physical_addr_ + (0x1000 * page_num);

zion/syscall/memory_object.cpp

@@ -14,8 +14,7 @@ z_err_t MemoryObjectCreate(ZMemoryObjectCreateReq* req) {
 z_err_t MemoryObjectCreatePhysical(ZMemoryObjectCreatePhysicalReq* req) {
   auto& curr_proc = gScheduler->CurrentProcess();
   uint64_t paddr = req->paddr;
-  auto vmmo_ref =
-      glcr::MakeRefCounted<FixedMemoryObject>(paddr, req->size, false);
+  auto vmmo_ref = glcr::MakeRefCounted<FixedMemoryObject>(paddr, req->size);
   *req->vmmo_cap =
       curr_proc.AddNewCapability(StaticCastRefPtr<MemoryObject>(vmmo_ref));
   return glcr::OK;
@@ -23,10 +22,8 @@ z_err_t MemoryObjectCreatePhysical(ZMemoryObjectCreatePhysicalReq* req) {
 
 z_err_t MemoryObjectCreateContiguous(ZMemoryObjectCreateContiguousReq* req) {
   auto& curr_proc = gScheduler->CurrentProcess();
-  uint64_t num_pages = ((req->size - 1) / 0x1000) + 1;
-  uint64_t paddr = phys_mem::AllocateContinuous(num_pages);
-  auto vmmo_ref =
-      glcr::MakeRefCounted<FixedMemoryObject>(paddr, req->size, true);
+  uint64_t paddr = phys_mem::AllocateContinuous(((req->size - 1) / 0x1000) + 1);
+  auto vmmo_ref = glcr::MakeRefCounted<FixedMemoryObject>(paddr, req->size);
   *req->vmmo_cap =
       curr_proc.AddNewCapability(StaticCastRefPtr<MemoryObject>(vmmo_ref));
   *req->paddr = paddr;