MaxOS::filesystem::VirtualFileSystem Class Reference

Combines all the filesystems across the partitions on each disk into a single filesystems and exposes a single API to interact with them. More...

#include <vfs.h>

Public Member Functions
	VirtualFileSystem ()
	Construct a new Virtual File System object and set it as the current file system.
	~VirtualFileSystem ()
	Destroy the Virtual File System object and unmount all filesystems.
void	mount_filesystem (FileSystem *filesystem)
	Add a filesystem to the virtual file system.
void	mount_filesystem (FileSystem *filesystem, const string &mount_point)
	Add a filesystem to the virtual file system at a given mount point.
void	unmount_filesystem (FileSystem *filesystem)
	Remove a filesystem from the virtual file system & delete it.
void	unmount_filesystem (const string &mount_point)
	Remove a filesystem from the virtual file system.
void	unmount_all ()
	Remove all mounted filesystems.
Directory *	root_directory ()
	Get the root directory of the virtual file system.
FileSystem *	root_filesystem ()
	Get the filesystem mounted at the root.
FileSystem *	get_filesystem (const string &mount_point)
	Get a specific filesystem mounted at a given mount point.
FileSystem *	find_filesystem (string path)
	Find the filesystem that is responsible for a given path.
string	get_relative_path (FileSystem *filesystem, string path)
	Get the relative path on a filesystem for a given VFS path (ie remove the mount point)
Directory *	open_directory (const string &path)
	Try to open a directory on the virtual file system and read it's contents.
Directory *	create_directory (string path)
	Attempts to open the parent directory and creates the sub directory at the end of the path.
void	delete_directory (string path)
	Attempts to open the parent directory and deletes the sub directory at the end of the path.
File *	create_file (const string &path)
	Attempts to open the parent directory and create the file at the end of the path.
File *	open_file (const string &path, size_t offset=0)
	Try to open a file on the virtual file system with a given offset.
void	delete_file (const string &path)
	Opens a directory on the vfs and deletes the file at the end of the path.

Static Public Member Functions
static VirtualFileSystem *	current_file_system ()
	Get the active virtual file system.
static Directory *	open_directory (Directory *parent, const string &name)
	Opens a subdirectory from a parent directory.
static Directory *	create_directory (Directory *parent, const string &name)
	Creates a subdirectory in the specified directory and.
static void	delete_directory (Directory *parent, const string &name)
	Delete a directory on the virtual file system and it's sub contents.
static void	delete_directory (Directory *parent, Directory *directory)
	Delete a directory on the virtual file system and it's sub contents.
static File *	create_file (Directory *parent, const string &name)
	Create a file in a directory.
static File *	open_file (Directory *parent, const string &name, size_t offset=0)
	Opens a file in a directory with the given offset.
static void	delete_file (Directory *parent, const string &name)
	Delete a file in the given directory.

Detailed Description

Combines all the filesystems across the partitions on each disk into a single filesystems and exposes a single API to interact with them.

Definition at line 25 of file vfs.h.

Constructor & Destructor Documentation

VirtualFileSystem()

VirtualFileSystem::VirtualFileSystem

(

)

Construct a new Virtual File System object and set it as the current file system.

Note

Only call once

Definition at line 21 of file vfs.cpp.

                                     {
 
    // Set the current file system to this instance
    s_current_file_system = this;
 
}

~VirtualFileSystem()

VirtualFileSystem::~VirtualFileSystem

(

)

Destroy the Virtual File System object and unmount all filesystems.

Definition at line 31 of file vfs.cpp.

                                      {
 
    // Remove all mounted filesystems
    unmount_all();
 
    // Set the current file system to null
    s_current_file_system = nullptr;
 
}

References unmount_all().

Member Function Documentation

create_directory() [1/2]

Directory * VirtualFileSystem::create_directory ( Directory *  parent, const string &  name  )

static

Creates a subdirectory in the specified directory and.

Parameters

parent	Where to create the directory
name	The name of the new directory

Returns

The created directory

Definition at line 322 of file vfs.cpp.

                                                                                    {
 
    // Create the directory
    Directory* directory = parent->create_subdirectory(name);
    directory->read_from_disk();
 
    return directory;
}

References MaxOS::filesystem::Directory::read_from_disk().

create_directory() [2/2]

Directory * VirtualFileSystem::create_directory

(

string

path

)

Attempts to open the parent directory and creates the sub directory at the end of the path.

Parameters

path	The path to the directory

Returns

The directory object or null if it could not be opened

Definition at line 293 of file vfs.cpp.

                                                          {
 
    // Ensure a valid path is given
    if (!Path::valid(path))
        return nullptr;
 
    path = path.strip('/');
 
    // Try to find the filesystem that is responsible for the path
    FileSystem* fs = find_filesystem(path);
    if (!fs)
        return nullptr;
 
    // Open the parent directory
    Directory* parent_directory = open_directory(path);
    if (!parent_directory)
        return nullptr;
 
    string directory_name = Path::file_name(path);
    return create_directory(parent_directory, directory_name);
}

References create_directory(), MaxOS::filesystem::Path::file_name(), find_filesystem(), open_directory(), and MaxOS::filesystem::Path::valid().

Referenced by create_directory(), and MaxOS::filesystem::VFSResourceRegistry::create_resource().

create_file() [1/2]

File * VirtualFileSystem::create_file

(

const string &

path

)

Attempts to open the parent directory and create the file at the end of the path.

Parameters

path	The path to the file (including the extension)

Returns

The file object or null if it could not be created

Definition at line 425 of file vfs.cpp.

                                                       {
 
    // Ensure a valid path is given
    if (!Path::valid(path))
        return nullptr;
 
    // Open the directory
    Directory* directory = open_directory(path);
    if (!directory)
        return nullptr;
 
    // Create the file
    string file_name = Path::file_name(path);
    return create_file(directory, file_name);
}

References create_file(), MaxOS::filesystem::Path::file_name(), open_directory(), and MaxOS::filesystem::Path::valid().

Referenced by create_file(), and MaxOS::filesystem::VFSResourceRegistry::create_resource().

create_file() [2/2]

File * VirtualFileSystem::create_file ( Directory *  parent, const string &  name  )

static

Create a file in a directory.

Parameters

parent	The directory where the file should be created
name	The name of the file to create

Returns

The created file or null pointer if it could not be created

Definition at line 448 of file vfs.cpp.

                                                                          {
    return parent->create_file(name);
}

current_file_system()

VirtualFileSystem * VirtualFileSystem::current_file_system ( )

static

Get the active virtual file system.

Returns

The current virtual file system or null if none is set

Definition at line 46 of file vfs.cpp.

                                                          {
    return s_current_file_system;
}

Referenced by MaxOS::filesystem::partition::MSDOSPartition::mount_partitions().

delete_directory() [1/3]

void VirtualFileSystem::delete_directory ( Directory *  parent, const string &  name  )

static

Delete a directory on the virtual file system and it's sub contents.

Parameters

parent	The directory that contains the reference to the directory being deleted
name	The name of the directory to delete

Definition at line 361 of file vfs.cpp.

                                                                              {
 
    // Find the directory and delete it
    for (const auto& directory: parent->subdirectories())
        if (directory->name() == name)
            delete_directory(parent, directory);
 
}

References delete_directory().

delete_directory() [2/3]

void VirtualFileSystem::delete_directory ( Directory *  parent, Directory *  directory  )

static

Delete a directory on the virtual file system and it's sub contents.

Parameters

parent	The directory that contains the reference to the directory being deleted
directory	The the directory to delete

Definition at line 376 of file vfs.cpp.

                                                                                {
 
    // Nothing to delete
    if (!directory)
        return;
 
    // Store a reference to each subdirectory and its parent
    Map<Directory*, Directory*> stack;
    Vector<Pair<Directory*, Directory*>> to_delete;
    stack.push_back(parent, directory);
 
    while (!stack.empty()) {
 
        // Save the current
        auto current = stack.pop_back();
        auto current_directory = current.second;
        current_directory->read_from_disk();
        to_delete.push_back({current.first, current_directory});
 
        // Empty the directory
        for (const auto &file: current_directory->files())
            delete_file(current_directory, file->name());
 
        // Process the subdirectories
        for (const auto &subdir: current_directory->subdirectories())
            if (subdir->name() != "." && subdir->name() != "..")
                stack.push_back(current_directory, subdir);
 
    }
 
    // Delete the directory from the bottom of the tree
    for (uint32_t i = to_delete.size() - 1; i >= 0; --i) {
 
        // Get the parent and child
        const auto &current = to_delete[i];
        Directory* owner = current.first;
        Directory* subdirectory = current.second;
 
        owner->remove_subdirectory(subdirectory->name());
    }
}

References delete_file(), and stack.

delete_directory() [3/3]

void VirtualFileSystem::delete_directory

(

string

path

)

Attempts to open the parent directory and deletes the sub directory at the end of the path.

Parameters

path	The path to the directory

Definition at line 337 of file vfs.cpp.

                                                    {
 
    // Ensure a valid path is given
    if (!Path::valid(path))
        return;
 
    path = path.strip('/');
 
    // Open the directory
    Directory* parent_directory = open_directory(path);
    if (!parent_directory)
        return;
 
    // Delete the directory
    string directory_name = Path::file_name(path);
    delete_directory(parent_directory, directory_name);
}

References delete_directory(), MaxOS::filesystem::Path::file_name(), open_directory(), and MaxOS::filesystem::Path::valid().

Referenced by delete_directory(), and delete_directory().

delete_file() [1/2]

void VirtualFileSystem::delete_file

(

const string &

path

)

Opens a directory on the vfs and deletes the file at the end of the path.

Parameters

path	The path to the file (including the extension)

Definition at line 499 of file vfs.cpp.

                                                      {
 
    // Ensure a valid path is given
    if (!Path::valid(path))
        return;
 
    // Open the directory
    Directory* directory = open_directory(path);
    if (!directory)
        return;
 
    // Delete the file
    string file_name = Path::file_name(path);
    delete_file(directory, file_name);
}

References delete_file(), MaxOS::filesystem::Path::file_name(), open_directory(), and MaxOS::filesystem::Path::valid().

Referenced by delete_directory(), and delete_file().

delete_file() [2/2]

void VirtualFileSystem::delete_file ( Directory *  parent, const string &  name  )

static

Delete a file in the given directory.

Parameters

parent	The directory containing the file
name	The name of the file

Definition at line 521 of file vfs.cpp.

                                                                         {
 
    // Delete the file
    parent->remove_file(name);
}

find_filesystem()

FileSystem * VirtualFileSystem::find_filesystem

(

string

path

)

Find the filesystem that is responsible for a given path.

Parameters

path	The path to search for

Returns

The filesystem that contains the path or null if none is found

Definition at line 191 of file vfs.cpp.

                                                          {
 
    // Longest matching path will be where the filesystem is mounted
    string longest_match = "";
    FileSystem* longest_match_fs = nullptr;
 
    // Search through the filesystems
    for (const auto& filesystem : filesystems) {
        // Get the filesystem and mount point
        FileSystem* fs = filesystem.first;
        string mount_point = filesystem.second;
 
        // Check if the path starts with the mount point
        if (path.starts_with(mount_point) && mount_point.length() > longest_match.length()) {
            longest_match = mount_point;
            longest_match_fs = fs;
        }
    }
 
    return longest_match_fs;
}

Referenced by create_directory(), and open_directory().

get_filesystem()

FileSystem * VirtualFileSystem::get_filesystem

(

const string &

mount_point

)

Get a specific filesystem mounted at a given mount point.

Parameters

mount_point

The mount point to search for

Returns

The filesystem mounted at the given mount point or null if none is found

Definition at line 174 of file vfs.cpp.

                                                                       {
 
    // Check if the filesystem is mounted
    for(const auto& filesystem : filesystems)
        if (filesystem.second == mount_point)
            return filesystem.first;
 
    // Filesystem not found
    return nullptr;
}

get_relative_path()

string VirtualFileSystem::get_relative_path	(	FileSystem *	filesystem,
		string	path
	)

Get the relative path on a filesystem for a given VFS path (ie remove the mount point)

Parameters

filesystem	The filesystem to get the path for
path	The path to get the relative path for

Returns

The relative path on the filesystem or an empty string if none is found

Definition at line 220 of file vfs.cpp.

                                                                               {
 
    // Find the mount point for the filesystem
    auto fs = filesystems.find(filesystem);
    if (fs == filesystems.end())
        return "";
 
    // Get the mount point
    string mount_point = fs->second;
 
    // Make sure that the path points to the filesystem
    if (!path.starts_with(mount_point))
        return "";
 
    // Get the relative path
    string relative_path = path.substring(mount_point.length(), path.length() - mount_point.length());
    return relative_path;
}

Referenced by open_directory().

mount_filesystem() [1/2]

void VirtualFileSystem::mount_filesystem

(

FileSystem *

filesystem

)

Add a filesystem to the virtual file system.

Parameters

filesystem

The filesystem to add

Definition at line 55 of file vfs.cpp.

                                                               {
 
    // Check if the filesystem is already mounted
    if (filesystems.find(filesystem) != filesystems.end()) {
        Logger::WARNING() << "Filesystem already mounted\n";
        return;
    }
 
    // Get the mount point for the filesystem
    string mount_point = "/filesystem_" + filesystems.size();
 
    // If this is the first filesystem to be mounted, set the root filesystem
    if (filesystems.size() == 0)
        mount_point = "/";
 
    // Add the filesystem to the map
    filesystems.insert(filesystem, mount_point);
}

References MaxOS::Logger::WARNING().

mount_filesystem() [2/2]

void VirtualFileSystem::mount_filesystem	(	FileSystem *	filesystem,
		const string &	mount_point
	)

Add a filesystem to the virtual file system at a given mount point.

Parameters

filesystem	The filesystem to add
mount_point	The mount point for the filesystem

Definition at line 80 of file vfs.cpp.

                                                                                          {
 
    // Check if the filesystem is already mounted
    if (filesystems.find(filesystem) != filesystems.end()) {
        Logger::WARNING() << "Filesystem already mounted at " << mount_point << "\n";
        return;
    }
 
    // Add the filesystem to the map
    filesystems.insert(filesystem, mount_point);
}

References MaxOS::Logger::WARNING().

open_directory() [1/2]

Directory * VirtualFileSystem::open_directory

(

const string &

path

)

Try to open a directory on the virtual file system and read it's contents.

Parameters

path	The path to the directory

Returns

The directory object or null if it could not be opened

Definition at line 245 of file vfs.cpp.

                                                               {
 
    // Ensure a valid path is given
    if (!Path::valid(path))
        return nullptr;
 
    // Try to find the filesystem that is responsible for the path
    FileSystem* fs = find_filesystem(path);
    if (!fs)
        return nullptr;
 
    // Get where to open the directory
    string relative_path = get_relative_path(fs, path);
    string directory_path = Path::file_path(relative_path);
 
    // Open the directory
    Directory* directory = fs->get_directory(directory_path);
    if (!directory)
        return nullptr;
    directory->read_from_disk();
 
    return directory;
}

References MaxOS::filesystem::Path::file_path(), find_filesystem(), get_relative_path(), MaxOS::filesystem::Directory::read_from_disk(), and MaxOS::filesystem::Path::valid().

Referenced by create_directory(), create_file(), delete_directory(), delete_file(), MaxOS::filesystem::VFSResourceRegistry::get_resource(), and open_file().

open_directory() [2/2]

Directory * VirtualFileSystem::open_directory ( Directory *  parent, const string &  name  )

static

Opens a subdirectory from a parent directory.

Parameters

parent	The parent directory
name	The name of the subdirectory

Returns

The opened subdirectory or null if it could not be opened

Definition at line 276 of file vfs.cpp.

                                                                                  {
 
    // Open the file
    Directory* opened_directory = parent->open_subdirectory(name);
    if (!opened_directory)
        return nullptr;
 
    opened_directory->read_from_disk();
    return opened_directory;
}

open_file() [1/2]

File * VirtualFileSystem::open_file	(	const string &	path,
		size_t	offset = 0
	)

Try to open a file on the virtual file system with a given offset.

Parameters

path	The path to the file (including the extension)
offset	The offset to seek to (default = 0)

Returns

The file or null pointer if not found

Definition at line 459 of file vfs.cpp.

                                                                    {
 
    // Ensure a valid path is given
    if (!Path::valid(path))
        return nullptr;
 
    // Open the directory
    Directory* directory = open_directory(path);
    if (!directory)
        return nullptr;
 
    return open_file(directory, Path::file_name(path), offset);
}

References MaxOS::filesystem::Path::file_name(), open_directory(), open_file(), and MaxOS::filesystem::Path::valid().

Referenced by MaxOS::filesystem::VFSResourceRegistry::get_resource(), and open_file().

open_file() [2/2]

File * VirtualFileSystem::open_file ( Directory *  parent, const string &  name, size_t  offset = 0  )

static

Opens a file in a directory with the given offset.

Parameters

parent	The directory containing the file
name	The name of the file to open
offset	How far in the file to open (default = 0)

Returns

The file or null pointer if not found

Definition at line 481 of file vfs.cpp.

                                                                                       {
 
    // Open the file
    File* opened_file = parent->open_file(name);
    if (!opened_file)
        return nullptr;
 
    // Seek to the offset
    opened_file->seek(SeekType::SET, offset);
 
    return opened_file;
}

root_directory()

Directory * VirtualFileSystem::root_directory

(

)

Get the root directory of the virtual file system.

Returns

The root directory of the virtual file system

Definition at line 142 of file vfs.cpp.

                                             {
 
    // Get the root filesystem
    FileSystem* fs = root_filesystem();
    if (!fs)
        return nullptr;
 
    // Get the root directory
    return fs->root_directory();
}

References root_filesystem().

root_filesystem()

FileSystem * VirtualFileSystem::root_filesystem

(

)

Get the filesystem mounted at the root.

Returns

The file system mounted "/" or null if none is mounted

Definition at line 158 of file vfs.cpp.

                                               {
 
    // Ensure there is at least one filesystem mounted
    if (filesystems.size() == 0)
        return nullptr;
 
    // It is always the first filesystem mounted
    return filesystems.begin()->first;
}

Referenced by root_directory().

unmount_all()

void VirtualFileSystem::unmount_all

(

)

Remove all mounted filesystems.

Definition at line 129 of file vfs.cpp.

                                    {
 
    // Loop through the filesystems and unmount them
    for(const auto& filesystem : filesystems)
        unmount_filesystem(filesystem.first);
 
}

References unmount_filesystem().

Referenced by ~VirtualFileSystem().

unmount_filesystem() [1/2]

void VirtualFileSystem::unmount_filesystem

(

const string &

mount_point

)

Remove a filesystem from the virtual file system.

Parameters

mount_point

Where the filesystem is mounted

Definition at line 115 of file vfs.cpp.

                                                                    {
 
    // Remove the filesystem from the map
    for(const auto& filesystem : filesystems)
        if (filesystem.second == mount_point)
            return unmount_filesystem(filesystem.first);
 
    // Filesystem not found
    Logger::WARNING() << "Filesystem not found at " << mount_point << "\n";
}

References unmount_filesystem(), and MaxOS::Logger::WARNING().

unmount_filesystem() [2/2]

void VirtualFileSystem::unmount_filesystem

(

FileSystem *

filesystem

)

Remove a filesystem from the virtual file system & delete it.

Parameters

filesystem

The filesystem to remove

Definition at line 97 of file vfs.cpp.

                                                                 {
 
    // Check if the filesystem is mounted
    if (filesystems.find(filesystem) == filesystems.end())
        return;
 
    // Remove the filesystem from the map
    filesystems.erase(filesystem);
 
    // Delete the filesystem
    delete filesystem;
}

Referenced by unmount_all(), and unmount_filesystem().

---

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

• /home/runner/work/MaxOS/MaxOS/kernel/include/filesystem/vfs.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/filesystem/vfs.cpp