Common operations for an ext2 volume that are used by both files & directories (like block & inode allocation) More...

#include <ext2.h>

Public Member Functions
	Ext2Volume (drivers::disk::Disk *disk, lba_t partition_offset)
	Construct a new Ext2 Volume object, reads the superblock and block group descriptors.

void	write_block (uint32_t block_num, common::buffer_t *buffer) const
	write a single block from a buffer into onto the disk

void	write_inode (uint32_t inode_num, inode_t *inode) const
	write an inode to the filesystem

uint32_t	create_inode (bool is_directory)
	Allocates a new inode and sets the base metadata. Also allocates block 0 of the inode.

void	free_inode (uint32_t inode)
	Mark an inode as free. Note: does NOT unallocated the inodes blocks, use free_group_blocks().

void	read_block (uint32_t block_num, common::buffer_t *buffer) const
	Reads a single block from the disk into a buffer.

inode_t	read_inode (uint32_t inode_num) const
	read an inode from the filesystem

uint32_t	allocate_block ()
	Allocates a single block to be used by an inode.

common::Vector< uint32_t >	allocate_blocks (uint32_t amount)
	Allocates a set of blocks to be used by an inode.

uint32_t	bytes_to_blocks (size_t bytes) const
	How many blocks are needed to contain a set amount of bytes.

void	free_blocks (const common::Vector< uint32_t > &blocks)
	Frees a group of blocks. Preferably with adjacent blocks apearing next to each other but not enforced.

Public Attributes
drivers::disk::Disk *	disk
	The disk that this volume is on.

lba_t	partition_offset
	How far into the disk this partition starts.

superblock_t	superblock
	The superblock of the ext2 filesystem.

block_group_descriptor_t **	block_groups
	The block group descriptors.

size_t	block_size
	How large each block is (in bytes)

uint32_t	block_group_descriptor_table_block
	Where the block group descriptor table starts.

uint32_t	block_group_descriptor_table_size
	How many block groups are in the block group descriptor table.

uint32_t	total_block_groups
	How many block groups are in the filesystem.

size_t	pointers_per_block
	How many block pointers fit in a block.

uint32_t	inodes_per_block
	How many inodes fit in a block.

uint32_t	sectors_per_block
	How many sectors does a block take.

common::Spinlock	ext2_lock
	Lock for synchronised access to the volume (.

Detailed Description

Common operations for an ext2 volume that are used by both files & directories (like block & inode allocation)

Todo:: Free blocks

Definition at line 322 of file ext2.h.

Constructor & Destructor Documentation

◆ Ext2Volume()

Ext2Volume::Ext2Volume	(	drivers::disk::Disk *	disk,
		lba_t	partition_offset
	)

Construct a new Ext2 Volume object, reads the superblock and block group descriptors.

Parameters

disk	The disk to read from
partition_offset	The offset of the partition on the disk in sectors

Todo:: Should lock per file and not expose volume lock

Definition at line 27 of file ext2.cpp.

: disk(disk),
  partition_offset(partition_offset),
  superblock({})
{
 
    // Read superblock
    buffer_t superblock_buffer(&superblock, 1024);
    disk->read(partition_offset + 2, &superblock_buffer, 512);
    disk->read(partition_offset + 3, &superblock_buffer, 512);
 
    // Validate signature
    ASSERT(superblock.signature == 0xEF53, "Ext2 Filesystem doesnt have a valid signature\n");
 
    // Version 0 has constant inode info
    if(superblock.version_major < 1) {
        superblock.first_inode = 11;
        superblock.inode_size = 128;
    }
 
    // Parse the superblock
    block_size = 1024 << superblock.block_size;
    total_block_groups = (superblock.total_blocks + superblock.blocks_per_group - 1) / superblock.blocks_per_group;
    block_group_descriptor_table_block = superblock.starting_block + 1;
    block_group_descriptor_table_size = total_block_groups * sizeof(block_group_descriptor_t);
    pointers_per_block = block_size / sizeof(uint32_t);
    inodes_per_block = block_size / superblock.inode_size;
    sectors_per_block = block_size / 512;
 
    // Read the block groups
    block_groups = new block_group_descriptor_t* [total_block_groups] { nullptr };
    uint32_t bgdt_lba = partition_offset + block_group_descriptor_table_block * sectors_per_block;
    uint32_t sectors_to_read = (block_group_descriptor_table_size + block_size - 1) / block_size * sectors_per_block;
    buffer_t bg_buffer(sectors_to_read * 512);
    for(uint32_t i = 0; i < sectors_to_read; ++i)
        disk->read(bgdt_lba + i, &bg_buffer, 512);
 
    // Store the block groups
    for(uint32_t i = 0; i < total_block_groups; ++i) {
        block_groups[i] = new block_group_descriptor_t;
        memcpy(block_groups[i], bg_buffer.raw() + i * sizeof(block_group_descriptor_t),
               sizeof(block_group_descriptor_t));
    }
}

Member Function Documentation

◆ allocate_block()

uint32_t Ext2Volume::allocate_block ( )

Allocates a single block to be used by an inode.

Returns: The new block number or 0 if the allocation failed

Definition at line 177 of file ext2.cpp.

                                    {
 
    return allocate_blocks(1)[0];
}

References allocate_blocks().

Referenced by create_inode().

◆ allocate_blocks()

Vector< uint32_t > Ext2Volume::allocate_blocks ( uint32_t amount )

Allocates a set of blocks to be used by an inode.

Parameters

amount The amount of blocks to allocate

Returns: A list of the allocated blocks or [0] if the allocation failed

Definition at line 188 of file ext2.cpp.

                                                            {
 
    // No blocks to allocate
    if(!amount)
        return { 1, 0 };
 
    // Find the block group with enough free blocks
    block_group_descriptor_t* block_group = block_groups[0];
    for(uint32_t bg_index = 0; bg_index < total_block_groups; block_group = block_groups[++bg_index])
        if(block_group->free_blocks >= amount)
            return allocate_group_blocks(bg_index, amount);
 
    // No block group can contain the block so split across multiple
    Vector<uint32_t> result { };
    while(amount > 0) {
 
        // Find the block group with most free blocks
        block_group = block_groups[0];
        uint32_t bg_index = 0;
        for(; bg_index < total_block_groups; ++bg_index)
            if(block_groups[bg_index]->free_blocks > block_group->free_blocks)
                block_group = block_groups[bg_index];
 
        // No space
        if(block_group->free_blocks == 0)
            return { 1, 0 };
 
        // Allocate the remaining blocks
        auto allocated = allocate_group_blocks(bg_index, 1);
        amount -= allocated.size();
        for(auto block : allocated)
            result.push_back(block);
    }
 
    return result;
}

References block_groups, free_blocks(), and total_block_groups.

Referenced by allocate_block(), and MaxOS::filesystem::format::ext2::InodeHandler::grow().

◆ bytes_to_blocks()

uint32_t Ext2Volume::bytes_to_blocks ( size_t bytes ) const

How many blocks are needed to contain a set amount of bytes.

Parameters

bytes Bytes needed

Returns: The blocks required

Definition at line 360 of file ext2.cpp.

                                                       {
    return (bytes + block_size - 1) / block_size;
}

References block_size.

Referenced by MaxOS::filesystem::format::ext2::InodeHandler::grow().

◆ create_inode()

uint32_t Ext2Volume::create_inode ( bool is_directory )

Allocates a new inode and sets the base metadata. Also allocates block 0 of the inode.

Parameters

is_directory is the inode to be used for a directory

Returns: The new inode

Definition at line 370 of file ext2.cpp.

                                                   {
 
    ext2_lock.lock();
 
    // Find the block group with enough free inodes
    block_group_descriptor_t* block_group = block_groups[0];
    uint32_t bg_index = 0;
    for(; bg_index < total_block_groups; block_group = block_groups[++bg_index])
        if(block_group->free_inodes >= 1)
            break;
 
    // Read bitmap
    buffer_t bitmap(block_size);
    read_block(block_group->block_inode_bitmap, &bitmap);
 
    // First group contains reserved inodes
    uint32_t inode_index = 0;
    if(bg_index == 0 && superblock.first_inode > 1)
        inode_index = superblock.first_inode - 1;
 
    // Find a free inode
    for(; inode_index < superblock.inodes_per_group; ++inode_index) {
 
        // Block is already used
        if((bitmap.raw()[inode_index / 8] & (1u << (inode_index % 8))) != 0)
            continue;
 
        // Mark as used
        block_group->free_inodes--;
        superblock.unallocated_inodes--;
        bitmap.raw()[inode_index / 8] |= (uint8_t) (1u << (inode_index % 8));
 
        break;
    }
 
    // Convert into the 1-based inode index in the group
    inode_index += bg_index * superblock.inodes_per_group + 1;
 
    // Save the changed metadata
    write_block(block_group->block_inode_bitmap, &bitmap);
    write_back_block_groups();
    write_back_superblock();
 
    // Create the inode
    inode_t inode { };
    inode.creation_time = time_to_epoch(Clock::active_clock()->get_time());
    inode.last_modification_time = time_to_epoch(Clock::active_clock()->get_time());
    inode.block_pointers[0] = allocate_block();
    inode.hard_links = is_directory ? 2 : 1;
    inode.type = ((uint16_t) (is_directory ? InodeType::DIRECTORY : InodeType::FILE) >> 12) & 0xF;
    inode.permissions =
            (uint16_t) (is_directory ? InodePermissionsDefaults::DIRECTORY : InodePermissionsDefaults::FILE) & 0x0FFF;
    write_inode(inode_index, &inode);
 
    ext2_lock.unlock();
    return inode_index;
}

References MaxOS::drivers::clock::Clock::active_clock(), allocate_block(), block_groups, block_size, ext2_lock, MaxOS::common::Spinlock::lock(), read_block(), superblock, total_block_groups, MaxOS::common::Spinlock::unlock(), write_block(), and write_inode().

◆ free_blocks()

void Ext2Volume::free_blocks ( const common::Vector< uint32_t > & blocks )

Frees a group of blocks. Preferably with adjacent blocks apearing next to each other but not enforced.

Parameters

blocks The blocks to free

Definition at line 464 of file ext2.cpp.

                                                                 {
 
    // No blocks to free
    if(blocks.empty())
        return;
 
    uint32_t start = blocks[0];
    uint32_t previous = start;
    uint32_t amount = 1;
 
    // Free each adjacent set of blocks
    for(auto& block : blocks) {
 
        // First is already accounted for
        if(block == start)
            continue;
 
        // Is this block adjacent
        if((previous + 1) == block) {
            previous = block;
            amount += 1;
            continue;
        }
 
        // Adjacent set has ended
        uint32_t group = (start - superblock.starting_block) / superblock.blocks_per_group;
        free_group_blocks(group, amount, start);
 
        // Reset
        start = block;
        previous = start;
        amount = 1;
    }
 
    // Account for the last set of blocks in the loop
    uint32_t group = (start - superblock.starting_block) / superblock.blocks_per_group;
    free_group_blocks(group, amount, start);
}

References superblock.

Referenced by allocate_blocks(), and MaxOS::filesystem::format::ext2::InodeHandler::free().

◆ free_inode()

void Ext2Volume::free_inode ( uint32_t inode )

Mark an inode as free. Note: does NOT unallocated the inodes blocks, use free_group_blocks().

See also: free_group_blocks

Parameters

inode The inode number to mark as free

Definition at line 434 of file ext2.cpp.

                                          {
 
    // Find the block group containing the inode
    uint32_t bg_index = (inode - 1) / superblock.inodes_per_group;
    block_group_descriptor_t* block_group = block_groups[bg_index];
 
    // Read bitmap
    buffer_t bitmap(block_size);
    read_block(block_group->block_inode_bitmap, &bitmap);
 
    // First group contains reserved inodes
    uint32_t inode_index = (inode - 1) % superblock.inodes_per_group;
    if(bg_index == 0 && (inode_index < (superblock.first_inode - 1)))
        return;
 
    // Mark as used
    block_group->free_inodes++;
    superblock.unallocated_inodes++;
    bitmap.raw()[inode_index / 8] &= (uint8_t) ~(1u << (inode_index % 8));
 
    // Save the changed metadata
    write_block(block_group->block_inode_bitmap, &bitmap);
    write_back_block_groups();
    write_back_superblock();
}

References block_groups, block_size, read_block(), superblock, and write_block().

Referenced by MaxOS::filesystem::format::ext2::InodeHandler::free().

◆ read_block()

void Ext2Volume::read_block	(	uint32_t	block_num,
		common::buffer_t *	buffer
	)		const

Reads a single block from the disk into a buffer.

Parameters

block_num	The block to read
buffer	The buffer to read into

Definition at line 129 of file ext2.cpp.

                                                                      {
 
    // Ensure the buffer is in the right format
    buffer->set_offset(0);
 
    // Read each sector of the block
    for(size_t i = 0; i < sectors_per_block; ++i)
        disk->read(partition_offset + block_num * sectors_per_block + i, buffer, 512);
 
    // Reset buffer
    buffer->set_offset(0);
 
}

References disk, partition_offset, MaxOS::drivers::disk::Disk::read(), sectors_per_block, and MaxOS::common::Buffer::set_offset().

Referenced by create_inode(), free_inode(), MaxOS::filesystem::format::ext2::Ext2File::read(), MaxOS::filesystem::format::ext2::Ext2Directory::read_from_disk(), read_inode(), MaxOS::filesystem::format::ext2::Ext2File::write(), and write_inode().

◆ read_inode()

inode_t Ext2Volume::read_inode ( uint32_t inode_num ) const

read an inode from the filesystem

Parameters

inode_num The inode index

Returns: The inode read

Definition at line 149 of file ext2.cpp.

                                                       {
 
    inode_t inode;
 
    // Locate the inode
    uint32_t group = (inode_num - 1) / superblock.inodes_per_group;
    uint32_t index = (inode_num - 1) % superblock.inodes_per_group;
 
    // Locate the block
    uint32_t inode_table = block_groups[group]->inode_table_address;
    uint32_t offset = index * superblock.inode_size;
    uint32_t block = offset / block_size;
    uint32_t in_block_offset = offset % block_size;
 
    // Read the block
    buffer_t buffer(block_size);
    read_block(inode_table + block, &buffer);
 
    // Read the inode from the block
    buffer.copy_to(&inode, sizeof(inode_t), in_block_offset);
    return inode;
}

References block_groups, block_size, MaxOS::common::Buffer::copy_to(), read_block(), and superblock.

◆ write_block()

void Ext2Volume::write_block	(	uint32_t	block_num,
		common::buffer_t *	buffer
	)		const

write a single block from a buffer into onto the disk

Parameters

block_num	The block to update
buffer	The buffer to read from

Definition at line 80 of file ext2.cpp.

                                                                       {
 
    // Ensure the buffer is in the right format
    buffer->set_offset(0);
    bool old = buffer->update_offset;
    buffer->update_offset = true;
 
    // Read each sector of the block
    for(size_t i = 0; i < sectors_per_block; ++i)
        disk->write(partition_offset + block_num * sectors_per_block + i, buffer, 512);
 
    // Reset buffer
    buffer->set_offset(0);
    buffer->update_offset = old;
}

References disk, partition_offset, sectors_per_block, MaxOS::common::Buffer::set_offset(), MaxOS::common::Buffer::update_offset, and MaxOS::drivers::disk::Disk::write().

Referenced by create_inode(), free_inode(), MaxOS::filesystem::format::ext2::Ext2File::write(), and write_inode().

◆ write_inode()

void Ext2Volume::write_inode	(	uint32_t	inode_num,
		inode_t *	inode
	)		const

write an inode to the filesystem

Parameters

inode_num	The inode index
inode	The inode to read from

Definition at line 102 of file ext2.cpp.

                                                                     {
 
    // Locate the inode
    uint32_t group = (inode_num - 1) / superblock.inodes_per_group;
    uint32_t index = (inode_num - 1) % superblock.inodes_per_group;
 
    // Locate the block
    uint32_t inode_table = block_groups[group]->inode_table_address;
    uint32_t offset = index * superblock.inode_size;
    uint32_t block = offset / block_size;
    uint32_t in_block_offset = offset % block_size;
 
    // Read the inode
    buffer_t buffer(block_size);
    read_block(inode_table + block, &buffer);
    buffer.copy_from(inode, sizeof(inode_t), in_block_offset);
 
    // Modify the block
    write_block(inode_table + block, &buffer);
}

References block_groups, block_size, MaxOS::common::Buffer::copy_from(), read_block(), superblock, and write_block().

Referenced by create_inode(), and MaxOS::filesystem::format::ext2::InodeHandler::save().

Member Data Documentation

◆ block_group_descriptor_table_block

uint32_t MaxOS::filesystem::format::ext2::Ext2Volume::block_group_descriptor_table_block

Where the block group descriptor table starts.

Definition at line 343 of file ext2.h.

◆ block_group_descriptor_table_size

uint32_t MaxOS::filesystem::format::ext2::Ext2Volume::block_group_descriptor_table_size

How many block groups are in the block group descriptor table.

Definition at line 344 of file ext2.h.

◆ block_groups

block_group_descriptor_t** MaxOS::filesystem::format::ext2::Ext2Volume::block_groups

The block group descriptors.

Definition at line 340 of file ext2.h.

Referenced by allocate_blocks(), create_inode(), free_inode(), read_inode(), and write_inode().

◆ block_size

size_t MaxOS::filesystem::format::ext2::Ext2Volume::block_size

How large each block is (in bytes)

Definition at line 342 of file ext2.h.

Referenced by bytes_to_blocks(), create_inode(), free_inode(), MaxOS::filesystem::format::ext2::InodeHandler::InodeHandler(), MaxOS::filesystem::format::ext2::Ext2File::read(), MaxOS::filesystem::format::ext2::Ext2Directory::read_from_disk(), read_inode(), MaxOS::filesystem::format::ext2::Ext2File::write(), and write_inode().

◆ disk

drivers::disk::Disk* MaxOS::filesystem::format::ext2::Ext2Volume::disk

The disk that this volume is on.

Definition at line 336 of file ext2.h.

Referenced by read_block(), and write_block().

◆ ext2_lock

common::Spinlock MaxOS::filesystem::format::ext2::Ext2Volume::ext2_lock

Lock for synchronised access to the volume (.

Todo:: : remove public?)

Definition at line 350 of file ext2.h.

Referenced by create_inode(), MaxOS::filesystem::format::ext2::InodeHandler::free(), MaxOS::filesystem::format::ext2::Ext2File::read(), MaxOS::filesystem::format::ext2::Ext2Directory::read_from_disk(), and MaxOS::filesystem::format::ext2::Ext2File::write().

◆ inodes_per_block

uint32_t MaxOS::filesystem::format::ext2::Ext2Volume::inodes_per_block

How many inodes fit in a block.

Definition at line 347 of file ext2.h.

◆ partition_offset

lba_t MaxOS::filesystem::format::ext2::Ext2Volume::partition_offset

How far into the disk this partition starts.

Definition at line 337 of file ext2.h.

Referenced by read_block(), and write_block().

◆ pointers_per_block

size_t MaxOS::filesystem::format::ext2::Ext2Volume::pointers_per_block

How many block pointers fit in a block.

Definition at line 346 of file ext2.h.

◆ sectors_per_block

uint32_t MaxOS::filesystem::format::ext2::Ext2Volume::sectors_per_block

How many sectors does a block take.

Definition at line 348 of file ext2.h.

Referenced by read_block(), and write_block().

◆ superblock

superblock_t MaxOS::filesystem::format::ext2::Ext2Volume::superblock

The superblock of the ext2 filesystem.

Definition at line 339 of file ext2.h.

Referenced by create_inode(), free_blocks(), free_inode(), read_inode(), and write_inode().

◆ total_block_groups

uint32_t MaxOS::filesystem::format::ext2::Ext2Volume::total_block_groups

How many block groups are in the filesystem.

Definition at line 345 of file ext2.h.

Referenced by allocate_blocks(), and create_inode().

The documentation for this class was generated from the following files:

/home/runner/work/MaxOS/MaxOS/kernel/include/filesystem/format/ext2.h
/home/runner/work/MaxOS/MaxOS/kernel/src/filesystem/format/ext2.cpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Ext2Volume()

Member Function Documentation

◆ allocate_block()

◆ allocate_blocks()

◆ bytes_to_blocks()

◆ create_inode()

◆ free_blocks()

◆ free_inode()

◆ read_block()

◆ read_inode()

◆ write_block()

◆ write_inode()

Member Data Documentation

◆ block_group_descriptor_table_block

◆ block_group_descriptor_table_size

◆ block_groups

◆ block_size

◆ disk

◆ ext2_lock

◆ inodes_per_block

◆ partition_offset

◆ pointers_per_block

◆ sectors_per_block

◆ superblock

◆ total_block_groups