drew
/
acadia
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

[Victoria Falls] Print only the root directory information. 

Move the InodeTable creating to the Init function which (somewhat)
requires us to stop taking the Ext2BlockReader as a reference (the reference
from the Init function goes out of scope). Make the Ext2BlockReader Init
function return a shared ptr by default.
This commit is contained in:
Drew Galbraith 2023-08-01 10:39:26 -07:00
parent bed685af65
commit 083ed52ddd
7 changed files with 44 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
sys/victoriafalls/fs/ext2/ext2_block_reader.cpp
View File

@ -1,11 +1,12 @@
#include "fs/ext2/ext2_block_reader.h"
glcr::ErrorOr<Ext2BlockReader> Ext2BlockReader::Init(
glcr::ErrorOr<glcr::SharedPtr<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 Ext2BlockReader(glcr::Move(denali), superblock);
return glcr::SharedPtr<Ext2BlockReader>(
new Ext2BlockReader(glcr::Move(denali), superblock));
}
Superblock* Ext2BlockReader::GetSuperblock() {

4
sys/victoriafalls/fs/ext2/ext2_block_reader.h
View File

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

46
sys/victoriafalls/fs/ext2/ext2_driver.cpp
View File

@ -4,14 +4,21 @@
#include <mammoth/debug.h>
glcr::ErrorOr<Ext2Driver> Ext2Driver::Init(ScopedDenaliClient&& denali) {
ASSIGN_OR_RETURN(Ext2BlockReader reader,
ASSIGN_OR_RETURN(glcr::SharedPtr<Ext2BlockReader> reader,
Ext2BlockReader::Init(glcr::Move(denali)));
Superblock* superblock = reader.GetSuperblock();
return Ext2Driver(glcr::Move(reader));
ASSIGN_OR_RETURN(
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;
@ -30,28 +37,11 @@ glcr::ErrorCode Ext2Driver::ProbePartition() {
dbgln("Created by: %x", superblock->creator_os);
ASSIGN_OR_RETURN(MappedMemoryRegion bgdt,
ext2_reader_.ReadBlocks(ext2_reader_.BgdtBlockNum(),
ext2_reader_.BgdtBlockSize()));
BlockGroupDescriptor* bgds =
reinterpret_cast<BlockGroupDescriptor*>(bgdt.vaddr());
return glcr::OK;
}
uint64_t num_block_groups = ext2_reader_.NumberOfBlockGroups();
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::ErrorOr<Inode*> Ext2Driver::GetInode(uint32_t inode_number) {
return inode_table_->GetInode(inode_number);
}
glcr::ErrorCode Ext2Driver::ProbeDirectory(Inode* inode) {
@ -62,7 +52,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");
@ -72,9 +62,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) {

7
sys/victoriafalls/fs/ext2/ext2_driver.h
View File

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

17
sys/victoriafalls/fs/ext2/inode_table.cpp
View File

@ -2,31 +2,32 @@
#include <mammoth/debug.h>
InodeTable::InodeTable(Ext2BlockReader& reader, BlockGroupDescriptor* bgdt)
InodeTable::InodeTable(const glcr::SharedPtr<Ext2BlockReader>& reader,
BlockGroupDescriptor* bgdt)
: ext2_reader_(reader), bgdt_(bgdt) {
inode_tables_.Resize(ext2_reader_.NumberOfBlockGroups());
inode_tables_.Resize(ext2_reader_->NumberOfBlockGroups());
}
glcr::ErrorOr<Inode*> InodeTable::GetInode(uint64_t inode_num) {
uint64_t inodes_per_group = ext2_reader_.GetSuperblock()->inodes_per_group;
glcr::ErrorOr<Inode*> InodeTable::GetInode(uint32_t inode_num) {
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_.InodeTableBlockSize()));
ext2_reader_->ReadBlocks(bgdt_[block_group_num].inode_table,
ext2_reader_->InodeTableBlockSize()));
}
return reinterpret_cast<Inode*>(inode_tables_[block_group_num].vaddr());
}

7
sys/victoriafalls/fs/ext2/inode_table.h
View File

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

3
sys/victoriafalls/victoriafalls.cpp
View File

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