sys/victoriafalls/fs/ext2/ext2_block_reader.cpp

@@ -1,12 +1,11 @@
 #include "fs/ext2/ext2_block_reader.h"
 
-glcr::ErrorOr<glcr::SharedPtr<Ext2BlockReader>> Ext2BlockReader::Init(
+glcr::ErrorOr<Ext2BlockReader> Ext2BlockReader::Init(
     ScopedDenaliClient&& denali) {
   // Read 1024 bytes from 1024 offset.
   // FIXME: Don't assume 512 byte sectors somehow.
   ASSIGN_OR_RETURN(MappedMemoryRegion superblock, denali.ReadSectors(2, 2));
-  return glcr::SharedPtr<Ext2BlockReader>(
+  return Ext2BlockReader(glcr::Move(denali), superblock);
-      new Ext2BlockReader(glcr::Move(denali), superblock));
 }
 
 Superblock* Ext2BlockReader::GetSuperblock() {

sys/victoriafalls/fs/ext2/ext2_block_reader.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <denali/denali_client.h>
-#include <glacier/memory/shared_ptr.h>
 #include <glacier/status/error_or.h>
 #include <mammoth/memory_region.h>
 
@@ -14,8 +13,7 @@
  * */
 class Ext2BlockReader {
  public:
-  static glcr::ErrorOr<glcr::SharedPtr<Ext2BlockReader>> Init(
+  static glcr::ErrorOr<Ext2BlockReader> Init(ScopedDenaliClient&& denali);
-      ScopedDenaliClient&& denali);
 
   // TODO: Consider creating a new class wrapper with these computations.
   Superblock* GetSuperblock();

sys/victoriafalls/fs/ext2/ext2_driver.cpp

@@ -4,21 +4,14 @@
 #include <mammoth/debug.h>
 
 glcr::ErrorOr<Ext2Driver> Ext2Driver::Init(ScopedDenaliClient&& denali) {
-  ASSIGN_OR_RETURN(glcr::SharedPtr<Ext2BlockReader> reader,
+  ASSIGN_OR_RETURN(Ext2BlockReader reader,
                    Ext2BlockReader::Init(glcr::Move(denali)));
-
+  Superblock* superblock = reader.GetSuperblock();
-  ASSIGN_OR_RETURN(
+  return Ext2Driver(glcr::Move(reader));
-      MappedMemoryRegion bgdt,
-      reader->ReadBlocks(reader->BgdtBlockNum(), reader->BgdtBlockSize()));
-  BlockGroupDescriptor* bgds =
-      reinterpret_cast<BlockGroupDescriptor*>(bgdt.vaddr());
-  glcr::UniquePtr<InodeTable> inode_table(new InodeTable(reader, bgds));
-
-  return Ext2Driver(reader, glcr::Move(inode_table));
 }
 
 glcr::ErrorCode Ext2Driver::ProbePartition() {
-  Superblock* superblock = ext2_reader_->GetSuperblock();
+  Superblock* superblock = ext2_reader_.GetSuperblock();
   if (superblock->magic != 0xEF53) {
     dbgln("Invalid EXT2 magic code: %x");
     return glcr::INVALID_ARGUMENT;
@@ -37,11 +30,28 @@ glcr::ErrorCode Ext2Driver::ProbePartition() {
 
   dbgln("Created by: %x", superblock->creator_os);
 
-  return glcr::OK;
+  ASSIGN_OR_RETURN(MappedMemoryRegion bgdt,
-}
+                   ext2_reader_.ReadBlocks(ext2_reader_.BgdtBlockNum(),
+                                           ext2_reader_.BgdtBlockSize()));
+  BlockGroupDescriptor* bgds =
+      reinterpret_cast<BlockGroupDescriptor*>(bgdt.vaddr());
 
-glcr::ErrorOr<Inode*> Ext2Driver::GetInode(uint32_t inode_number) {
+  uint64_t num_block_groups = ext2_reader_.NumberOfBlockGroups();
-  return inode_table_->GetInode(inode_number);
+  for (uint64_t i = 0; i < num_block_groups; i++) {
+    dbgln("BGD %x", i);
+    dbgln("Block Bitmap: %x", bgds[i].block_bitmap);
+    dbgln("Inode Bitmap: %x", bgds[i].inode_bitmap);
+    dbgln("Inode Table: %x", bgds[i].inode_table);
+    dbgln("Free blocks: %x", bgds[i].free_blocks_count);
+    dbgln("Free inodes: %x", bgds[i].free_inodes_count);
+  }
+
+  // FIXME: Move this to initialization.
+  inode_table_ =
+      glcr::UniquePtr<InodeTable>(new InodeTable(ext2_reader_, bgds));
+
+  ASSIGN_OR_RETURN(Inode * root, inode_table_->GetInode(2));
+  return ProbeDirectory(root);
 }
 
 glcr::ErrorCode Ext2Driver::ProbeDirectory(Inode* inode) {
@@ -52,7 +62,7 @@ glcr::ErrorCode Ext2Driver::ProbeDirectory(Inode* inode) {
 
   // This calculation is cursed.
   uint64_t real_block_cnt =
-      (inode->blocks - 1) / (ext2_reader_->BlockSize() / 512) + 1;
+      (inode->blocks - 1) / (ext2_reader_.BlockSize() / 512) + 1;
 
   if (real_block_cnt > 12) {
     dbgln("Cant handle indirect blocks yet");
@@ -62,9 +72,9 @@ glcr::ErrorCode Ext2Driver::ProbeDirectory(Inode* inode) {
   for (uint64_t i = 0; i < real_block_cnt; i++) {
     dbgln("Getting block %lx", inode->block[i]);
     ASSIGN_OR_RETURN(MappedMemoryRegion block,
-                     ext2_reader_->ReadBlock(inode->block[i]));
+                     ext2_reader_.ReadBlock(inode->block[i]));
     uint64_t addr = block.vaddr();
-    while (addr < block.vaddr() + ext2_reader_->BlockSize()) {
+    while (addr < block.vaddr() + ext2_reader_.BlockSize()) {
       DirEntry* entry = reinterpret_cast<DirEntry*>(addr);
       glcr::String name(entry->name, entry->name_len);
       switch (entry->file_type) {

sys/victoriafalls/fs/ext2/ext2_driver.h

@@ -13,14 +13,11 @@ class Ext2Driver {
 
   glcr::ErrorCode ProbePartition();
 
-  glcr::ErrorOr<Inode*> GetInode(uint32_t inode_number);
   glcr::ErrorCode ProbeDirectory(Inode* inode);
 
  private:
-  glcr::SharedPtr<Ext2BlockReader> ext2_reader_;
+  Ext2BlockReader ext2_reader_;
   glcr::UniquePtr<InodeTable> inode_table_;
 
-  Ext2Driver(const glcr::SharedPtr<Ext2BlockReader>& reader,
+  Ext2Driver(Ext2BlockReader&& reader) : ext2_reader_(glcr::Move(reader)) {}
-             glcr::UniquePtr<InodeTable> inode_table)
-      : ext2_reader_(reader), inode_table_(glcr::Move(inode_table)) {}
 };

sys/victoriafalls/fs/ext2/inode_table.cpp

@@ -2,32 +2,31 @@
 
 #include <mammoth/debug.h>
 
-InodeTable::InodeTable(const glcr::SharedPtr<Ext2BlockReader>& reader,
+InodeTable::InodeTable(Ext2BlockReader& reader, BlockGroupDescriptor* bgdt)
-                       BlockGroupDescriptor* bgdt)
     : ext2_reader_(reader), bgdt_(bgdt) {
-  inode_tables_.Resize(ext2_reader_->NumberOfBlockGroups());
+  inode_tables_.Resize(ext2_reader_.NumberOfBlockGroups());
 }
 
-glcr::ErrorOr<Inode*> InodeTable::GetInode(uint32_t inode_num) {
+glcr::ErrorOr<Inode*> InodeTable::GetInode(uint64_t inode_num) {
-  uint64_t inodes_per_group = ext2_reader_->GetSuperblock()->inodes_per_group;
+  uint64_t inodes_per_group = ext2_reader_.GetSuperblock()->inodes_per_group;
   uint64_t block_group_num = (inode_num - 1) / inodes_per_group;
   ASSIGN_OR_RETURN(Inode * root, GetRootOfInodeTable(block_group_num));
   uint64_t local_index = (inode_num - 1) % inodes_per_group;
   return reinterpret_cast<Inode*>(reinterpret_cast<uint64_t>(root) +
-                                  local_index * ext2_reader_->InodeSize());
+                                  local_index * ext2_reader_.InodeSize());
 }
 
 glcr::ErrorOr<Inode*> InodeTable::GetRootOfInodeTable(
     uint64_t block_group_num) {
-  if (block_group_num > ext2_reader_->NumberOfBlockGroups()) {
+  if (block_group_num > ext2_reader_.NumberOfBlockGroups()) {
     return glcr::INVALID_ARGUMENT;
   }
 
   if (!inode_tables_[block_group_num]) {
     ASSIGN_OR_RETURN(
         inode_tables_[block_group_num],
-        ext2_reader_->ReadBlocks(bgdt_[block_group_num].inode_table,
+        ext2_reader_.ReadBlocks(bgdt_[block_group_num].inode_table,
-                                 ext2_reader_->InodeTableBlockSize()));
+                                ext2_reader_.InodeTableBlockSize()));
   }
   return reinterpret_cast<Inode*>(inode_tables_[block_group_num].vaddr());
 }

sys/victoriafalls/fs/ext2/inode_table.h

@@ -7,13 +7,12 @@
 
 class InodeTable {
  public:
-  InodeTable(const glcr::SharedPtr<Ext2BlockReader>& driver,
+  InodeTable(Ext2BlockReader& driver, BlockGroupDescriptor* bgdt);
-             BlockGroupDescriptor* bgdt);
 
-  glcr::ErrorOr<Inode*> GetInode(uint32_t inode_num);
+  glcr::ErrorOr<Inode*> GetInode(uint64_t inode_num);
 
  private:
-  glcr::SharedPtr<Ext2BlockReader> ext2_reader_;
+  Ext2BlockReader& ext2_reader_;
   BlockGroupDescriptor* bgdt_;
 
   glcr::Vector<MappedMemoryRegion> inode_tables_;

sys/victoriafalls/victoriafalls.cpp

@@ -13,8 +13,7 @@ uint64_t main(uint64_t init_cap) {
   ASSIGN_OR_RETURN(ScopedDenaliClient denali, yellowstone.GetDenali());
   ASSIGN_OR_RETURN(Ext2Driver ext2, Ext2Driver::Init(glcr::Move(denali)));
 
-  ASSIGN_OR_RETURN(Inode * root, ext2.GetInode(2));
+  check(ext2.ProbePartition());
-  check(ext2.ProbeDirectory(root));
 
   return 0;
 }

zion/scheduler/scheduler.cpp

@@ -86,6 +86,7 @@ void Scheduler::Yield() {
     if (runnable_threads_.size() == 0) {
       current_thread_ = sleep_thread_;
       dbgln("Sleeping");
+      gProcMan->DumpProcessStates();
     } else {
       current_thread_ = runnable_threads_.PopFront();
     }