Merge remote-tracking branch 'Kernel/master'

Kernel/storage/cache.cpp

@@ -0,0 +1,226 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <filesystem.hpp>
+
+#include <convert.h>
+#include <printf.h>
+#include <rand.hpp>
+#include <cwalk.h>
+
+#include "../kernel.h"
+
+namespace vfs
+{
+	FileNode *Virtual::CacheSearchReturnLast(FileNode *Parent, const char **Path)
+	{
+		assert(Parent != nullptr);
+
+		struct cwk_segment segment;
+		if (!cwk_path_get_first_segment(*Path, &segment))
+		{
+			if (strcmp(*Path, Parent->fsi->RootName) == 0)
+				return Parent;
+
+			ReturnLogError(nullptr, "Failed to get first segment of path");
+		}
+
+		size_t segments = 0;
+		while (cwk_path_get_next_segment(&segment))
+			segments++;
+
+		if (segments == 0)
+			return Parent;
+
+		const char *tmpPath = *Path;
+		if (strncmp(tmpPath, "\x06root-", 6) == 0) /* FIXME: deduce the index */
+		{
+			tmpPath += 6;
+			while (*tmpPath != '\0' && *tmpPath != '\x06')
+				tmpPath++;
+			if (*tmpPath == '\x06')
+				tmpPath++;
+		}
+		else
+			tmpPath = *Path;
+
+		FileNode *__Parent = Parent;
+		if (this->PathIsAbsolute(tmpPath))
+		{
+			while (__Parent->Parent)
+				__Parent = __Parent->Parent;
+		}
+
+		cwk_path_get_first_segment(tmpPath, &segment);
+		do
+		{
+			std::string segmentName(segment.begin, segment.size);
+
+			bool found = false;
+			for (FileNode *fn : __Parent->Children)
+			{
+				if (fn->Name != segmentName)
+					continue;
+
+				cwk_segment __seg = segment;
+				assert(cwk_path_get_next_segment(&__seg)); /* There's something wrong */
+
+				__Parent = fn;
+				found = true;
+				break;
+			}
+
+			if (!found)
+			{
+				*Path = segment.begin;
+				break;
+			}
+		} while (cwk_path_get_next_segment(&segment));
+
+		return __Parent;
+	}
+
+	FileNode *Virtual::CacheRecursiveSearch(FileNode *Root, const char *NameOrPath, bool IsName)
+	{
+		if (Root == nullptr)
+			return nullptr;
+
+		debug("%s cache search for \"%s\" in \"%s\"",
+			  IsName ? "Relative" : "Absolute",
+			  NameOrPath,
+			  Root->Path.c_str());
+
+		struct cwk_segment segment;
+		if (!cwk_path_get_first_segment(NameOrPath, &segment))
+		{
+			if (strcmp(NameOrPath, Root->fsi->RootName) == 0)
+				return Root;
+			ReturnLogError(nullptr, "Failed to get first segment of path");
+		}
+
+		size_t segments = 0;
+		while (cwk_path_get_next_segment(&segment))
+			segments++;
+
+		if (IsName && segments == 0)
+		{
+			for (FileNode *fn : Root->Children)
+			{
+				if (fn->Name == NameOrPath)
+					return fn;
+			}
+
+			ReturnLogError(nullptr, "Failed to find \"%s\" in \"%s\"", NameOrPath, Root->Path.c_str());
+		}
+
+		const char *path = NameOrPath;
+		if (strncmp(path, "\x06root-", 6) == 0) /* FIXME: deduce the index */
+		{
+			path += 6;
+			while (*path != '\0' && *path != '\x06')
+				path++;
+			if (*path == '\x06')
+				path++;
+		}
+		else
+			path = NameOrPath;
+
+		FileNode *__Parent = Root;
+		if (this->PathIsAbsolute(path))
+		{
+			/* Get the root if Root is not the root 【・_・?】 */
+			while (__Parent->Parent)
+				__Parent = __Parent->Parent;
+		}
+
+		cwk_path_get_first_segment(path, &segment);
+		do
+		{
+			std::string segmentName(segment.begin, segment.size);
+
+			bool found = false;
+			for (FileNode *fn : __Parent->Children)
+			{
+				if (fn->Name != segmentName)
+					continue;
+
+				cwk_segment __seg = segment;
+				if (!cwk_path_get_next_segment(&__seg))
+					return fn;
+
+				__Parent = fn;
+				found = true;
+				break;
+			}
+
+			if (!found)
+				break;
+		} while (cwk_path_get_next_segment(&segment));
+
+		debug("Failed to find \"%s\" in \"%s\"", NameOrPath, Root->Path.c_str());
+		return nullptr;
+	}
+
+	FileNode *Virtual::CacheLookup(const char *Path)
+	{
+		debug("Cache lookup for \"%s\"", Path);
+		FileNode *rootNode = thisProcess ? thisProcess->Info.RootNode : this->GetRoot(0);
+
+		FileNode *ret = CacheRecursiveSearch(rootNode, Path, false);
+		if (ret)
+			return ret;
+
+		debug("Path \"%s\" not found", Path);
+		return nullptr;
+	}
+
+	FileNode *Virtual::CreateCacheNode(FileNode *Parent, Inode *Node, const char *Name, mode_t Mode)
+	{
+		FileNode *fn = new FileNode;
+		fn->Name = Name;
+		if (Parent)
+		{
+			fn->Path = Parent->Path + "/" + Name;
+			Parent->Children.push_back(fn);
+		}
+		else
+			fn->Path = Name;
+		fn->Parent = Parent;
+		fn->Node = Node;
+		fn->fsi = DeviceMap[Node->Device].fsi;
+		if (fn->fsi == nullptr)
+			warn("Failed to find filesystem for device %d", Node->Device);
+
+		debug("Created cache node %s", fn->Path.c_str());
+		return fn;
+	}
+
+	int Virtual::RemoveCacheNode(FileNode *Node)
+	{
+		if (Node == nullptr)
+			return -EINVAL;
+
+		if (Node->Parent)
+		{
+			Node->Parent->Children.erase(std::find(Node->Parent->Children.begin(), Node->Parent->Children.end(), Node));
+			// delete Node;
+			fixme("Node deletion is disabled for now (for debugging purposes)");
+		}
+
+		return 0;
+	}
+}

Kernel/storage/descriptor.cpp

@@ -0,0 +1,378 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <filesystem.hpp>
+
+#include <convert.h>
+#include <stropts.h>
+#include <task.hpp>
+#include <printf.h>
+#include <lock.hpp>
+#include <cwalk.h>
+
+#include "../kernel.h"
+
+namespace vfs
+{
+	int FileDescriptorTable::GetFlags(int FileDescriptor)
+	{
+		auto it = this->FileMap.find(FileDescriptor);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", FileDescriptor);
+
+		return it->second.Flags;
+	}
+
+	int FileDescriptorTable::SetFlags(int FileDescriptor, int Flags)
+	{
+		auto it = this->FileMap.find(FileDescriptor);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", FileDescriptor);
+
+		it->second.Flags = Flags;
+		return 0;
+	}
+
+	int FileDescriptorTable::AddFileDescriptor(const char *AbsolutePath,
+											   mode_t Mode, int Flags)
+	{
+		Tasking::PCB *pcb = thisProcess;
+
+		auto ProbeMode = [](mode_t Mode, int Flags) -> int
+		{
+			if (!(Flags & O_CREAT))
+				return 0;
+
+			if (Flags & O_RDONLY)
+			{
+				if (!(Mode & S_IRUSR))
+				{
+					debug("No read permission (%d)", Mode);
+					return -EACCES;
+				}
+			}
+
+			if (Flags & O_WRONLY)
+			{
+				if (!(Mode & S_IWUSR))
+				{
+					debug("No write permission (%d)", Mode);
+					return -EACCES;
+				}
+			}
+
+			if (Flags & O_RDWR)
+			{
+				if (!(Mode & S_IRUSR) ||
+					!(Mode & S_IWUSR))
+				{
+					debug("No read/write permission (%d)", Mode);
+					return -EACCES;
+				}
+			}
+
+			return 0;
+		};
+
+		if (ProbeMode(Mode, Flags) < 0)
+			return -EACCES;
+
+		fixme("Do not follow symlinks when O_CREAT and O_EXCL are set");
+
+		if (Flags & O_CREAT)
+		{
+			FileNode *ret = fs->Create(pcb->CWD, AbsolutePath, Mode);
+			if (Flags & O_EXCL && ret == nullptr)
+			{
+				debug("%s: File already exists?, returning EEXIST",
+					  AbsolutePath);
+				return -EEXIST;
+			}
+		}
+
+		if (Flags & O_CLOEXEC)
+		{
+			fixme("O_CLOEXEC");
+		}
+
+		FileNode *File = fs->GetByPath(AbsolutePath, pcb->CWD);
+
+		if (!File)
+		{
+			error("Failed to open file %s", AbsolutePath);
+			return -ENOENT;
+		}
+
+		if (Flags & O_TRUNC)
+		{
+			debug("Truncating file %s", AbsolutePath);
+			File->Truncate(0);
+		}
+
+		Fildes fd{};
+
+		if (Flags & O_APPEND)
+		{
+			debug("Appending to file %s", AbsolutePath);
+			struct kstat stat;
+			File->Stat(&stat);
+			fd.Offset = File->Seek(stat.Size);
+		}
+
+		fd.Mode = Mode;
+		fd.Flags = Flags;
+		fd.Node = File;
+
+		int fdn = this->GetFreeFileDescriptor();
+		if (fdn < 0)
+			return fdn;
+
+		this->FileMap.insert({fdn, fd});
+
+		char linkName[64];
+		snprintf(linkName, 64, "%d", fdn);
+		assert(fs->CreateLink(linkName, this->fdDir, AbsolutePath) != nullptr);
+
+		File->Open(Flags, Mode);
+		return fdn;
+	}
+
+	int FileDescriptorTable::RemoveFileDescriptor(int FileDescriptor)
+	{
+		auto it = this->FileMap.find(FileDescriptor);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", FileDescriptor);
+
+		fs->Remove(it->second.Node);
+		this->FileMap.erase(it);
+		return 0;
+	}
+
+	int FileDescriptorTable::GetFreeFileDescriptor()
+	{
+		Tasking::PCB *pcb = thisProcess;
+
+		for (size_t i = 0; i < pcb->SoftLimits.OpenFiles; i++)
+		{
+			auto it = this->FileMap.find(i);
+			if (it == this->FileMap.end())
+				return i;
+		}
+
+		return -EMFILE;
+	}
+
+	void FileDescriptorTable::Fork(FileDescriptorTable *Parent)
+	{
+		this->FileMap = Parent->FileMap;
+
+		for (const auto &fd : this->FileMap)
+		{
+			if (fd.second.Flags & O_CLOEXEC)
+			{
+				debug("O_CLOEXEC flag set, removing fd %d", fd.first);
+				this->FileMap.erase(fd.first);
+			}
+		}
+	}
+
+	int FileDescriptorTable::usr_open(const char *pathname, int flags, mode_t mode)
+	{
+		if (pathname == nullptr)
+			return -EFAULT;
+
+		return AddFileDescriptor(pathname, mode, flags);
+	}
+
+	int FileDescriptorTable::usr_creat(const char *pathname, mode_t mode)
+	{
+		return usr_open(pathname, O_WRONLY | O_CREAT | O_TRUNC, mode);
+	}
+
+	ssize_t FileDescriptorTable::usr_read(int fd, void *buf, size_t count)
+	{
+		auto it = this->FileMap.find(fd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", fd);
+
+		return it->second.Node->Read(buf, count, it->second.Offset);
+	}
+
+	ssize_t FileDescriptorTable::usr_write(int fd, const void *buf, size_t count)
+	{
+		auto it = this->FileMap.find(fd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", fd);
+
+		return it->second.Node->Write(buf, count, it->second.Offset);
+	}
+
+	int FileDescriptorTable::usr_close(int fd)
+	{
+		auto it = this->FileMap.find(fd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", fd);
+
+		return RemoveFileDescriptor(fd);
+	}
+
+	off_t FileDescriptorTable::usr_lseek(int fd, off_t offset, int whence)
+	{
+		auto it = this->FileMap.find(fd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", fd);
+
+		off_t &newOffset = it->second.Offset;
+
+		switch (whence)
+		{
+		case SEEK_SET:
+		{
+			newOffset = it->second.Node->Seek(offset);
+			break;
+		}
+		case SEEK_CUR:
+		{
+			newOffset = it->second.Node->Seek(newOffset + offset);
+			break;
+		}
+		case SEEK_END:
+		{
+			struct kstat stat
+			{
+			};
+			it->second.Node->Stat(&stat);
+			newOffset = it->second.Node->Seek(stat.Size + offset);
+			break;
+		}
+		default:
+			return -EINVAL;
+		}
+
+		return newOffset;
+	}
+
+	int FileDescriptorTable::usr_stat(const char *pathname,
+									  struct kstat *statbuf)
+	{
+		FileNode *node = fs->GetByPath(pathname, nullptr);
+		if (node == nullptr)
+			ReturnLogError(-ENOENT, "Failed to find %s", pathname);
+
+		if (node->IsSymbolicLink())
+		{
+			std::unique_ptr<char[]> buffer(new char[1024]);
+			ssize_t ret = node->ReadLink(buffer.get(), 1024);
+			if (ret < 0)
+				return ret;
+
+			FileNode *target = fs->GetByPath(buffer.get(), nullptr);
+			if (target == nullptr)
+				return -ENOENT;
+
+			return target->Stat(statbuf);
+		}
+
+		return node->Stat(statbuf);
+	}
+
+	int FileDescriptorTable::usr_fstat(int fd, struct kstat *statbuf)
+	{
+		auto it = this->FileMap.find(fd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", fd);
+
+		vfs::FileDescriptorTable::Fildes &fildes = it->second;
+
+		return fildes.Node->Stat(statbuf);
+	}
+
+	int FileDescriptorTable::usr_lstat(const char *pathname,
+									   struct kstat *statbuf)
+	{
+		FileNode *node = fs->GetByPath(pathname, nullptr);
+		if (node == nullptr)
+			ReturnLogError(-ENOENT, "Failed to find %s", pathname);
+		return node->Stat(statbuf);
+	}
+
+	int FileDescriptorTable::usr_dup(int oldfd)
+	{
+		auto it = this->FileMap.find(oldfd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", oldfd);
+
+		int newfd = this->GetFreeFileDescriptor();
+		if (newfd < 0)
+			return -EMFILE;
+
+		Fildes new_dfd{};
+		new_dfd.Node = it->second.Node;
+		new_dfd.Mode = it->second.Mode;
+
+		this->FileMap.insert({newfd, new_dfd});
+
+		debug("Duplicated file descriptor %d to %d", oldfd, newfd);
+		return newfd;
+	}
+
+	int FileDescriptorTable::usr_dup2(int oldfd, int newfd)
+	{
+		if (newfd < 0)
+			ReturnLogError(-EBADF, "Invalid newfd %d", newfd);
+
+		auto it = this->FileMap.find(oldfd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid oldfd %d", oldfd);
+
+		if (newfd == oldfd)
+			return newfd;
+
+		/* Even if it's not valid we ignore it. */
+		this->usr_close(newfd);
+
+		Fildes new_dfd{};
+		new_dfd.Node = it->second.Node;
+		new_dfd.Mode = it->second.Mode;
+
+		this->FileMap.insert({newfd, new_dfd});
+		debug("Duplicated file descriptor %d to %d", oldfd, newfd);
+		return newfd;
+	}
+
+	int FileDescriptorTable::usr_ioctl(int fd, unsigned long request, void *argp)
+	{
+		auto it = this->FileMap.find(fd);
+		if (it == this->FileMap.end())
+			ReturnLogError(-EBADF, "Invalid fd %d", fd);
+
+		return it->second.Node->Ioctl(request, argp);
+	}
+
+	FileDescriptorTable::FileDescriptorTable(void *_Owner)
+		: Owner(_Owner)
+	{
+		debug("+ %#lx", this);
+
+		mode_t Mode = S_IXOTH | S_IROTH |
+					  S_IXGRP | S_IRGRP |
+					  S_IXUSR | S_IRUSR |
+					  S_IFDIR;
+
+		this->fdDir = fs->Create(((Tasking::PCB *)_Owner)->ProcDirectory, "fd", Mode);
+	}
+}

Kernel/storage/filesystem.cpp

@@ -0,0 +1,310 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <filesystem.hpp>
+
+#include <convert.h>
+#include <printf.h>
+#include <rand.hpp>
+#include <cwalk.h>
+
+#include "../kernel.h"
+
+namespace vfs
+{
+	bool Virtual::PathIsRelative(const char *Path)
+	{
+		return cwk_path_is_relative(Path);
+	}
+
+	void Virtual::AddRoot(Inode *Root)
+	{
+		SmartLock(VirtualLock);
+		FileSystemRoots->Children.push_back(Root);
+	}
+
+	FileNode *Virtual::GetRoot(size_t Index)
+	{
+		assert(Index < FileSystemRoots->Children.size());
+
+		auto it = FileRoots.find(Index);
+		if (it != FileRoots.end())
+			return it->second;
+
+		Inode *rootNode = FileSystemRoots->Children[Index];
+		char rootName[128]{};
+		snprintf(rootName, sizeof(rootName), "\x06root-%ld\x06", Index);
+		FileNode *ret = this->CreateCacheNode(nullptr, rootNode, rootName, 0);
+		FileRoots.insert({Index, ret});
+		return ret;
+	}
+
+	FileNode *Virtual::Create(FileNode *Parent, const char *Name, mode_t Mode)
+	{
+		FileNode *existingNode = this->GetByPath(Name, Parent);
+		if (existingNode != nullptr)
+			ReturnLogError(existingNode, "File %s already exists", Name);
+
+		if (Parent == nullptr)
+		{
+			assert(thisProcess != nullptr);
+			Parent = thisProcess->Info.RootNode;
+		}
+
+		auto it = DeviceMap.find(Parent->Node->Device);
+		if (it == DeviceMap.end())
+			ReturnLogError(nullptr, "Device %d not found", Parent->Node->Device);
+
+		Inode *Node = NULL;
+		if (it->second.fsi->Ops.Create == NULL)
+			ReturnLogError(nullptr, "Create not supported for %d", it->first);
+
+		int ret = it->second.fsi->Ops.Create(Parent->Node, Name, Mode, &Node);
+		if (ret < 0)
+			ReturnLogError(nullptr, "Create for %d failed with %d", it->first, ret);
+
+		return this->CreateCacheNode(Parent, Node, Name, Mode);
+	}
+
+	FileNode *Virtual::ForceCreate(FileNode *Parent, const char *Name, mode_t Mode)
+	{
+		fixme("ForceCreate: %s", Name);
+		return this->Create(Parent, Name, Mode);
+	}
+
+	FileNode *Virtual::Mount(FileNode *Parent, Inode *Node, const char *Path)
+	{
+		char *path = strdup(Path);
+		char *lastSlash = strrchr(path, '/');
+		if (lastSlash == path)
+			lastSlash++;
+		*lastSlash = '\0';
+
+		FileNode *parentNode = this->GetByPath(path, Parent);
+		free(path);
+		lastSlash = strrchr(Path, '/');
+		lastSlash++;
+		return this->CreateCacheNode(parentNode, Node, lastSlash, Node->Mode);
+	}
+
+	int Virtual::Unmount(const char *Path)
+	{
+		FileNode *node = this->GetByPath(Path, nullptr);
+		if (node == nullptr)
+			ReturnLogError(-ENOENT, "Path %s not found", Path);
+
+		return this->RemoveCacheNode(node);
+	}
+
+	FileNode *Virtual::GetByPath(const char *Path, FileNode *Parent)
+	{
+		debug("GetByPath: %s", Path);
+		if (Parent == nullptr || this->PathIsAbsolute(Path))
+			Parent = thisProcess ? thisProcess->Info.RootNode : this->GetRoot(0);
+
+		if (strcmp(Path, ".") == 0)
+			return Parent;
+
+		if (strcmp(Path, "..") == 0)
+			return Parent->Parent ? Parent->Parent : Parent;
+
+		FileNode *fn = this->CacheRecursiveSearch(Parent, Path, this->PathIsRelative(Path));
+		if (fn)
+			return fn;
+
+		if (strncmp(Path, "\x06root-", 6) == 0) /* FIXME: deduce the index */
+		{
+			Path += 7;
+			while (*Path != '\0' && *Path != '\x06')
+				Path++;
+			if (*Path == '\x06')
+				Path++;
+		}
+
+		FileNode *__Parent = CacheSearchReturnLast(Parent, &Path);
+
+		struct cwk_segment segment;
+		if (!cwk_path_get_first_segment(Path, &segment))
+		{
+			auto it = DeviceMap.find(Parent->Node->Device);
+			if (unlikely(it == DeviceMap.end()))
+				ReturnLogError(nullptr, "Device %d not found", Parent->Node->Device);
+
+			if (it->second.fsi->Ops.Lookup == NULL)
+				ReturnLogError(nullptr, "Lookup not supported for %d", it->first);
+
+			Inode *Node = NULL;
+			int ret = it->second.fsi->Ops.Lookup(Parent->Node, Path, &Node);
+			if (ret < 0)
+				ReturnLogError(nullptr, "Lookup for \"%s\"(%d) failed with %d", Path, it->first, ret);
+
+			if (Parent->Node == Node) /* root / */
+			{
+				debug("Returning root (%#lx)", Node);
+				return Parent;
+			}
+			ReturnLogError(nullptr, "Path has no segments");
+		}
+
+		Inode *Node = NULL;
+		do
+		{
+			auto it = DeviceMap.find(__Parent->Node->Device);
+			if (unlikely(it == DeviceMap.end()))
+				ReturnLogError(nullptr, "Device %d not found", __Parent->Node->Device);
+
+			if (it->second.fsi->Ops.Lookup == NULL)
+				ReturnLogError(nullptr, "Lookup not supported for %d", it->first);
+
+			std::string segmentName(segment.begin, segment.size);
+			int ret = it->second.fsi->Ops.Lookup(__Parent->Node, segmentName.c_str(), &Node);
+			if (ret < 0)
+				ReturnLogError(nullptr, "Lookup for \"%s\"(%d) failed with %d", segmentName.c_str(), it->first, ret);
+			__Parent = this->CreateCacheNode(__Parent, Node, segmentName.c_str(), 0);
+		} while (cwk_path_get_next_segment(&segment));
+
+		FileNode *ret = __Parent;
+		if (!ret->IsDirectory())
+			return ret;
+
+		auto it = DeviceMap.find(__Parent->Node->Device);
+		if (unlikely(it == DeviceMap.end()))
+			ReturnLogError(nullptr, "Device %d not found", __Parent->Node->Device);
+
+		size_t dirAllocLen = sizeof(struct kdirent) + strlen(Path);
+		struct kdirent *dirent = (struct kdirent *)malloc(dirAllocLen);
+		size_t offset = 2; /* Skip . and .. */
+		while (it->second.fsi->Ops.ReadDir(Node, dirent, dirAllocLen, offset++, 1) > 0)
+		{
+			Inode *ChildNode = NULL;
+			int luRet = it->second.fsi->Ops.Lookup(Node, dirent->d_name, &ChildNode);
+			if (luRet < 0)
+			{
+				debug("Lookup for %d failed with %d", it->first, luRet);
+				break;
+			}
+
+			this->CreateCacheNode(ret, ChildNode, dirent->d_name, 0);
+		}
+		free(dirent);
+		return ret;
+	}
+
+	std::string Virtual::GetByNode(FileNode *Node)
+	{
+		assert(Node != nullptr);
+		if (Node->Parent == nullptr)
+		{
+			if (Node->Node->Flags & I_FLAG_ROOT)
+				return Node->fsi->RootName;
+			assert(Node->Parent != nullptr);
+		}
+
+		std::string path;
+
+		auto appendPath = [&path](const char *name)
+		{
+			if (path.size() > 0)
+				path += "/";
+			path += name;
+		};
+
+		FileNode *current = Node;
+		while (current->Parent != nullptr)
+		{
+			appendPath(current->Name.c_str());
+			current = current->Parent;
+		}
+
+		return path;
+	}
+
+	FileNode *Virtual::CreateLink(const char *Path, FileNode *Parent, const char *Target)
+	{
+		auto it = DeviceMap.find(Parent->Node->Device);
+		if (it == DeviceMap.end())
+			ReturnLogError(nullptr, "Device %d not found", Parent->Node->Device);
+
+		Inode *Node = NULL;
+
+		if (it->second.fsi->Ops.SymLink == NULL)
+			ReturnLogError(nullptr, "SymLink not supported for %d", it->first);
+
+		int ret = it->second.fsi->Ops.SymLink(Parent->Node, Path, Target, &Node);
+		if (ret < 0)
+			ReturnLogError(nullptr, "SymLink for %d failed with %d", it->first, ret);
+		return this->CreateCacheNode(Parent, Node, Path, 0);
+	}
+
+	FileNode *Virtual::CreateLink(const char *Path, FileNode *Parent, FileNode *Target)
+	{
+		return this->CreateLink(Path, Parent, Target->Path.c_str());
+	}
+
+	bool Virtual::PathExists(const char *Path, FileNode *Parent)
+	{
+		FileNode *fn = this->CacheLookup(Path);
+		if (fn)
+			return true;
+
+		FileNode *Node = this->GetByPath(Path, Parent);
+		if (Node)
+			return true;
+		return false;
+	}
+
+	int Virtual::Remove(FileNode *Node)
+	{
+		auto it = DeviceMap.find(Node->Node->Device);
+		if (it == DeviceMap.end())
+			ReturnLogError(-ENODEV, "Device %d not found", Node->Node->Device);
+
+		if (it->second.fsi->Ops.Remove == NULL)
+			ReturnLogError(-ENOTSUP, "Remove not supported for %d", it->first);
+
+		int ret = it->second.fsi->Ops.Remove(Node->Parent->Node, Node->Name.c_str());
+		if (ret < 0)
+			ReturnLogError(ret, "Remove for %d failed with %d", it->first, ret);
+
+		this->RemoveCacheNode(Node);
+		return 0;
+	}
+}
+
+std::string FileNode::GetName()
+{
+	return this->Name;
+}
+
+std::string FileNode::GetPath()
+{
+	const char *path = this->Path.c_str();
+	if (strncmp(path, "\x06root-", 6) == 0) /* FIXME: deduce the index */
+	{
+		path += 6;
+		while (*path != '\0' && *path != '\x06')
+			path++;
+		if (*path == '\x06')
+			path++;
+	}
+	else
+		return this->Path;
+
+	if (path[0] == '\0')
+		return std::string(this->fsi->RootName);
+	return std::string(path);
+}

Kernel/storage/fs/ustar.cpp

@@ -0,0 +1,868 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <filesystem/ustar.hpp>
+
+#include <memory.hpp>
+#include <functional>
+#include <debug.h>
+
+#include "../../kernel.h"
+
+#define TMAGIC "ustar"
+#define TMAGLEN 6
+#define TVERSION "00"
+#define TVERSLEN 2
+
+namespace vfs
+{
+	int USTAR::Lookup(struct Inode *_Parent, const char *Name, struct Inode **Result)
+	{
+		auto Parent = (USTARInode *)_Parent;
+
+		const char *basename;
+		size_t length;
+		cwk_path_get_basename(Name, &basename, &length);
+		if (basename == NULL)
+		{
+			if (strcmp(Name, "/") == 0)
+			{
+				auto &it = Files.at(0);
+				*Result = &it->Node;
+				return 0;
+			}
+
+			error("Invalid name %s", Name);
+			return -EINVAL;
+		}
+
+		if (_Parent)
+		{
+			for (const auto &child : Parent->Children)
+			{
+				if (child->Deleted || strcmp(child->Name.c_str(), basename) != 0)
+					continue;
+
+				*Result = &child->Node;
+				return 0;
+			}
+
+			return -ENOENT;
+		}
+
+		auto fileItr = Files.begin();
+		while (fileItr != Files.end())
+		{
+			USTARInode *node = fileItr->second;
+
+			if (node->Deleted || strcmp(node->Name.c_str(), basename) != 0)
+			{
+				fileItr++;
+				continue;
+			}
+
+			*Result = &fileItr->second->Node;
+			return 0;
+		}
+		return -ENOENT;
+	}
+
+	int USTAR::Create(struct Inode *_Parent, const char *Name, mode_t Mode, struct Inode **Result)
+	{
+		USTARInode *Parent = (USTARInode *)_Parent;
+
+		Inode inode{};
+		inode.Mode = Mode;
+		inode.Device = this->DeviceID;
+		inode.RawDevice = 0;
+		inode.Index = NextInode;
+		inode.Offset = 0;
+		inode.PrivateData = this;
+		inode.Flags = I_FLAG_CACHE_KEEP;
+
+		const char *basename;
+		size_t length;
+		cwk_path_get_basename(Name, &basename, &length);
+
+		auto SetMode = [&](mode_t &Mode, FileHeader *header)
+		{
+			if (Mode & S_IFREG)
+				header->typeflag[0] = REGTYPE;
+			else if (Mode & S_IFLNK)
+				header->typeflag[0] = SYMTYPE;
+			else if (Mode & S_IFCHR)
+				header->typeflag[0] = CHRTYPE;
+			else if (Mode & S_IFBLK)
+				header->typeflag[0] = BLKTYPE;
+			else if (Mode & S_IFDIR)
+				header->typeflag[0] = DIRTYPE;
+			else if (Mode & S_IFIFO)
+				header->typeflag[0] = FIFOTYPE;
+
+			mode_t final = 0;
+			if (Mode & S_ISUID)
+				final |= TSUID;
+			else if (Mode & S_ISGID)
+				final |= TSGID;
+			else if (Mode & S_ISVTX)
+				final |= TSVTX;
+			else if (Mode & S_IRUSR)
+				final |= TUREAD;
+			else if (Mode & S_IWUSR)
+				final |= TUWRITE;
+			else if (Mode & S_IXUSR)
+				final |= TUEXEC;
+			else if (Mode & S_IRGRP)
+				final |= TGREAD;
+			else if (Mode & S_IWGRP)
+				final |= TGWRITE;
+			else if (Mode & S_IXGRP)
+				final |= TGEXEC;
+			else if (Mode & S_IROTH)
+				final |= TOREAD;
+			else if (Mode & S_IWOTH)
+				final |= TOWRITE;
+			else if (Mode & S_IXOTH)
+				final |= TOEXEC;
+
+			snprintf(header->mode, sizeof(header->mode), "%07o", final);
+		};
+
+		FileHeader *hdr = new FileHeader{};
+		SetMode(inode.Mode, hdr);
+		strncpy(hdr->name, basename, sizeof(hdr->name));
+		strncpy(hdr->signature, TMAGIC, TMAGLEN);
+		strncpy(hdr->version, TVERSION, TVERSLEN);
+
+		USTARInode *node = new USTARInode{.Node = inode,
+										  .Header = hdr,
+										  .Parent = Parent,
+										  .Name{},
+										  .Path{},
+										  .Children{},
+										  .Deleted = false,
+										  .Checksum = INODE_CHECKSUM};
+
+		node->Name.assign(basename, length);
+		node->Path.assign(Name, strlen(Name));
+
+		Files.insert(std::make_pair(NextInode, node));
+		*Result = &Files.at(NextInode)->Node;
+		if (Parent)
+			Parent->Children.push_back(Files.at(NextInode));
+		NextInode++;
+		return 0;
+	}
+
+	ssize_t USTAR::Read(struct Inode *Node, void *Buffer, size_t Size, off_t Offset)
+	{
+		auto fileItr = Files.find(Node->Index);
+		assert(fileItr != Files.end());
+
+		if (fileItr->second->Deleted)
+			return -ENOENT;
+
+		USTARInode *node = fileItr->second;
+		size_t fileSize = GetSize(node->Header->size);
+
+		if (Size <= 0)
+		{
+			debug("Size is less than or equal to 0");
+			Size = fileSize;
+		}
+
+		if ((size_t)Offset > fileSize)
+		{
+			debug("Offset %d is greater than file size %d", Offset, fileSize);
+			return 0;
+		}
+
+		if ((fileSize - Offset) == 0)
+		{
+			debug("Offset %d is equal to file size %d", Offset, fileSize);
+			return 0; /* EOF */
+		}
+
+		if ((size_t)Offset + Size > fileSize)
+		{
+			debug("Offset %d + Size %d is greater than file size %d",
+				  Offset, Size, fileSize);
+			Size = fileSize;
+		}
+
+		memcpy(Buffer, (uint8_t *)((uintptr_t)node->Header + sizeof(FileHeader) + Offset), Size);
+		// debug("Read %d bytes from %d[%d]", Size, Node->Index, Offset);
+		return Size;
+	}
+
+	__no_sanitize("alignment")
+		ssize_t USTAR::ReadDir(struct Inode *_Node, struct kdirent *Buffer, size_t Size, off_t Offset, off_t Entries)
+	{
+		/* FIXME: FIX ALIGNMENT FOR DIRENT! */
+		auto Node = (USTARInode *)_Node;
+
+		off_t realOffset = Offset;
+
+		size_t totalSize = 0;
+		uint16_t reclen = 0;
+		struct kdirent *ent = nullptr;
+
+		if (Offset == 0)
+		{
+			reclen = (uint16_t)(offsetof(struct kdirent, d_name) + strlen(".") + 1);
+			if (totalSize + reclen >= Size)
+				return -EINVAL;
+
+			ent = (struct kdirent *)((uintptr_t)Buffer + totalSize);
+			ent->d_ino = Node->Node.Index;
+			ent->d_off = Offset++;
+			ent->d_reclen = reclen;
+			ent->d_type = DT_DIR;
+			strcpy(ent->d_name, ".");
+			totalSize += reclen;
+		}
+
+		if (Offset <= 1)
+		{
+			reclen = (uint16_t)(offsetof(struct kdirent, d_name) + strlen("..") + 1);
+			if (totalSize + reclen >= Size)
+			{
+				if (realOffset == 1)
+					return -EINVAL;
+				return totalSize;
+			}
+
+			ent = (struct kdirent *)((uintptr_t)Buffer + totalSize);
+
+			if (Node->Parent)
+				ent->d_ino = Node->Parent->Node.Index;
+			else
+			{
+				warn("Parent is null for %s", Node->Name.c_str());
+				ent->d_ino = Node->Node.Index;
+			}
+			ent->d_off = Offset++;
+			ent->d_reclen = reclen;
+			ent->d_type = DT_DIR;
+			strcpy(ent->d_name, "..");
+			totalSize += reclen;
+		}
+
+		// off_t entriesSkipped = 0;
+		// auto fileItr = Files.begin();
+		// while (fileItr != Files.end())
+		// {
+		// 	if (fileItr->second->Deleted)
+		// 		continue;
+		// 	reclen = (uint16_t)(offsetof(struct kdirent, d_name) + strlen(fileItr->second->Name.c_str()) + 1);
+		// 	if (Offset > entriesSkipped)
+		// 	{
+		// 		entriesSkipped++;
+		// 		continue;
+		// 	}
+		// 	if (totalSize + reclen >= Size)
+		// 		break;
+		// 	ent = (struct kdirent *)((uintptr_t)Buffer + totalSize);
+		// 	ent->d_ino = fileItr->first;
+		// 	ent->d_off = Offset++;
+		// 	ent->d_reclen = reclen;
+		// 	ent->d_type = IFTODT(StringToInt(fileItr->second->Header->mode));
+		// 	strncpy(ent->d_name,
+		// 			fileItr->second->Name.c_str(),
+		// 			strlen(fileItr->second->Name.c_str()));
+		// 	totalSize += reclen;
+		// 	fileItr++;
+		// }
+
+		if (!S_ISDIR(Node->Node.Mode))
+			return -ENOTDIR;
+
+		if ((Offset >= 2 ? (Offset - 2) : Offset) > (off_t)Node->Children.size())
+			return -EINVAL;
+
+		off_t entries = 0;
+		for (const auto &var : Node->Children)
+		{
+			if (var->Node.Offset < Offset)
+				continue;
+
+			if (entries >= Entries)
+				break;
+
+			if (var->Deleted)
+				continue;
+
+			reclen = (uint16_t)(offsetof(struct kdirent, d_name) + strlen(var->Name.c_str()) + 1);
+
+			if (totalSize + reclen >= Size)
+				break;
+
+			ent = (struct kdirent *)((uintptr_t)Buffer + totalSize);
+			ent->d_ino = var->Node.Index;
+			ent->d_off = var->Node.Offset;
+			ent->d_reclen = reclen;
+			switch (var->Header->typeflag[0])
+			{
+			case AREGTYPE:
+			case REGTYPE:
+				ent->d_type = DT_REG;
+				break;
+			case LNKTYPE:
+				fixme("Hard link not implemented for %s", var->Header->name);
+				ent->d_type = DT_LNK;
+				break;
+			case SYMTYPE:
+				ent->d_type = DT_LNK;
+				break;
+			case CHRTYPE:
+				ent->d_type = DT_CHR;
+				break;
+			case BLKTYPE:
+				ent->d_type = DT_BLK;
+				break;
+			case DIRTYPE:
+				ent->d_type = DT_DIR;
+				break;
+			case FIFOTYPE:
+				ent->d_type = DT_FIFO;
+				break;
+			case CONTTYPE:
+			default:
+				ent->d_type = 0;
+				break;
+			}
+			strncpy(ent->d_name, var->Name.c_str(), strlen(var->Name.c_str()));
+
+			totalSize += reclen;
+			entries++;
+		}
+
+		if (totalSize + sizeof(struct kdirent) >= Size)
+			return totalSize;
+
+		ent = (struct kdirent *)((uintptr_t)Buffer + totalSize);
+		ent->d_ino = 0;
+		ent->d_off = 0;
+		ent->d_reclen = 0;
+		ent->d_type = DT_UNKNOWN;
+		ent->d_name[0] = '\0';
+		return totalSize;
+	}
+
+	int USTAR::SymLink(struct Inode *Node, const char *Name, const char *Target, struct Inode **Result)
+	{
+		int ret = this->Create(Node, Name, S_IFLNK, Result);
+		if (ret < 0)
+			return ret;
+
+		USTARInode *node = (USTARInode *)*Result;
+		FileHeader *hdr = node->Header;
+		strncpy(hdr->link, Target, MIN(sizeof(hdr->link) - 1, strlen(Target)));
+		return 0;
+	}
+
+	ssize_t USTAR::ReadLink(struct Inode *Node, char *Buffer, size_t Size)
+	{
+		auto fileItr = Files.find(Node->Index);
+		assert(fileItr != Files.end());
+
+		if (fileItr->second->Deleted)
+			return -ENOENT;
+
+		USTARInode *node = fileItr->second;
+
+		if (strlen(node->Header->link) > Size)
+			Size = strlen(node->Header->link);
+
+		strncpy(Buffer, node->Header->link, Size);
+		debug("Read %d bytes from %d", Size, Node->Index);
+		return Size;
+	}
+
+	int USTAR::Stat(struct Inode *Node, struct kstat *Stat)
+	{
+		auto fileItr = Files.find(Node->Index);
+		assert(fileItr != Files.end());
+		if (fileItr->second->Deleted)
+			return -ENOENT;
+
+		USTARInode *node = fileItr->second;
+		size_t fileSize = GetSize(node->Header->size);
+
+		debug("Header: \"%.*s\"", sizeof(struct FileHeader), node->Header);
+		Stat->Device = this->DeviceID;
+		Stat->Index = Node->Index;
+		Stat->HardLinks = 1;
+		Stat->UserID = GetSize(node->Header->uid);
+		Stat->GroupID = GetSize(node->Header->gid);
+		Stat->RawDevice = Stat->MakeDevice(GetSize(node->Header->dev_maj), GetSize(node->Header->dev_min));
+		Stat->Size = fileSize;
+		Stat->AccessTime = GetSize(node->Header->mtime);
+		Stat->ModifyTime = GetSize(node->Header->mtime);
+		Stat->ChangeTime = GetSize(node->Header->mtime);
+		Stat->BlockSize = 512;
+		Stat->Blocks = (fileSize + 511) / 512;
+		Stat->Attribute = 0;
+
+		mode_t hdrMode = StringToInt(node->Header->mode);
+
+		if (hdrMode & TSUID)
+			Stat->Mode |= S_ISUID;
+		else if (hdrMode & TSGID)
+			Stat->Mode |= S_ISGID;
+		else if (hdrMode & TSVTX)
+			Stat->Mode |= S_ISVTX;
+		else if (hdrMode & TUREAD)
+			Stat->Mode |= S_IRUSR;
+		else if (hdrMode & TUWRITE)
+			Stat->Mode |= S_IWUSR;
+		else if (hdrMode & TUEXEC)
+			Stat->Mode |= S_IXUSR;
+		else if (hdrMode & TGREAD)
+			Stat->Mode |= S_IRGRP;
+		else if (hdrMode & TGWRITE)
+			Stat->Mode |= S_IWGRP;
+		else if (hdrMode & TGEXEC)
+			Stat->Mode |= S_IXGRP;
+		else if (hdrMode & TOREAD)
+			Stat->Mode |= S_IROTH;
+		else if (hdrMode & TOWRITE)
+			Stat->Mode |= S_IWOTH;
+		else if (hdrMode & TOEXEC)
+			Stat->Mode |= S_IXOTH;
+
+		switch (node->Header->typeflag[0])
+		{
+		case AREGTYPE:
+		case REGTYPE:
+			Stat->Mode |= S_IFREG;
+			break;
+		case LNKTYPE:
+			fixme("Hard link not implemented for %s", node->Header->name);
+			Stat->Mode |= S_IFLNK;
+			break;
+		case SYMTYPE:
+			Stat->Mode |= S_IFLNK;
+			break;
+		case CHRTYPE:
+			Stat->Mode |= S_IFCHR;
+			break;
+		case BLKTYPE:
+			Stat->Mode |= S_IFBLK;
+			break;
+		case DIRTYPE:
+			Stat->Mode |= S_IFDIR;
+			break;
+		case FIFOTYPE:
+			Stat->Mode |= S_IFIFO;
+			break;
+		case CONTTYPE:
+			warn("Reserved type for %s", node->Header->name);
+			__fallthrough;
+		default:
+			error("Unknown type: %d for %s", node->Header->typeflag[0], node->Header->name);
+			break;
+		}
+		return 0;
+	}
+
+	bool USTAR::TestArchive(uintptr_t Address)
+	{
+		if (!Memory::Virtual().Check((void *)Address))
+		{
+			error("Address %#lx is not mapped!", Address);
+			return false;
+		}
+
+		FileHeader *header = (FileHeader *)Address;
+		if (strncmp(header->signature, TMAGIC, TMAGLEN) != 0)
+		{
+			error("Invalid signature!");
+			return false;
+		}
+		return true;
+	}
+
+	void USTAR::ReadArchive(uintptr_t Address, size_t Size)
+	{
+		trace("Initializing USTAR with address %#lx and size %d", Address, Size);
+
+		auto SetMode = [&](Inode &uNode, FileHeader *header)
+		{
+			mode_t hdrMode = StringToInt(header->mode);
+			if (hdrMode & TSUID)
+				uNode.Mode |= S_ISUID;
+			else if (hdrMode & TSGID)
+				uNode.Mode |= S_ISGID;
+			else if (hdrMode & TSVTX)
+				uNode.Mode |= S_ISVTX;
+			else if (hdrMode & TUREAD)
+				uNode.Mode |= S_IRUSR;
+			else if (hdrMode & TUWRITE)
+				uNode.Mode |= S_IWUSR;
+			else if (hdrMode & TUEXEC)
+				uNode.Mode |= S_IXUSR;
+			else if (hdrMode & TGREAD)
+				uNode.Mode |= S_IRGRP;
+			else if (hdrMode & TGWRITE)
+				uNode.Mode |= S_IWGRP;
+			else if (hdrMode & TGEXEC)
+				uNode.Mode |= S_IXGRP;
+			else if (hdrMode & TOREAD)
+				uNode.Mode |= S_IROTH;
+			else if (hdrMode & TOWRITE)
+				uNode.Mode |= S_IWOTH;
+			else if (hdrMode & TOEXEC)
+				uNode.Mode |= S_IXOTH;
+
+			switch (header->typeflag[0])
+			{
+			case AREGTYPE:
+			case REGTYPE:
+				uNode.Mode |= S_IFREG;
+				break;
+			case LNKTYPE:
+				uNode.Mode |= S_IFLNK;
+				break;
+			case SYMTYPE:
+				uNode.Mode |= S_IFLNK;
+				break;
+			case CHRTYPE:
+				uNode.Mode |= S_IFCHR;
+				break;
+			case BLKTYPE:
+				uNode.Mode |= S_IFBLK;
+				break;
+			case DIRTYPE:
+				uNode.Mode |= S_IFDIR;
+				break;
+			case FIFOTYPE:
+				uNode.Mode |= S_IFIFO;
+				break;
+			case CONTTYPE:
+				warn("Reserved type for %s", header->name);
+				__fallthrough;
+			default:
+				error("Unknown type: %d for %s", header->typeflag[0], header->name);
+				break;
+			}
+		};
+
+		FileHeader *header = (FileHeader *)Address;
+
+		debug("USTAR signature valid! Name:%s Signature:%s Mode:%d Size:%lu",
+			  header->name, header->signature, StringToInt(header->mode), header->size);
+
+		Memory::Virtual vmm;
+		std::vector<USTARInode *> tmpNodes; /* FIXME: bug in unordered_map for iterators */
+		for (size_t i = 0;; i++)
+		{
+			if (!vmm.Check((void *)header))
+			{
+				error("Address %#lx is not mapped!", header);
+				return;
+			}
+
+			if (strncmp(header->signature, TMAGIC, TMAGLEN) != 0)
+				break;
+			// debug("\"%s\"", header->name);
+
+			/* This removes the "." at the beginning of the file name
+				"./foo/bar" > "/foo/bar" */
+			if (header->name[0] == '.' && header->name[1] == '/')
+				memmove(header->name, header->name + 1, strlen(header->name));
+
+			if (isempty((char *)header->name))
+				fixme("Ignoring empty file name \"%.*s\"", sizeof(struct FileHeader), header);
+
+			struct Inode uNode;
+			uNode.Device = this->DeviceID;
+			uNode.RawDevice = 0;
+			uNode.Index = NextInode;
+			SetMode(uNode, header);
+			uNode.Flags = I_FLAG_CACHE_KEEP;
+			uNode.Offset = 0;
+			uNode.PrivateData = this;
+
+			const char *basename;
+			size_t length;
+			cwk_path_get_basename(header->name, &basename, &length);
+
+			USTARInode *node = new USTARInode{.Node = uNode,
+											  .Header = header,
+											  .Parent = nullptr,
+											  .Name{},
+											  .Path{},
+											  .Children{},
+											  .Deleted = false,
+											  .Checksum = INODE_CHECKSUM};
+
+			if (basename)
+				node->Name.assign(basename, length);
+			else
+				node->Name.assign((const char *)header->name, strlen(header->name));
+			node->Path.assign((const char *)header->name, strlen(header->name));
+
+			Files.insert(std::make_pair(NextInode, node));
+			tmpNodes.push_back(node);
+
+			size_t size = GetSize(header->size);
+			Address += ((size / 512) + 1) * 512;
+			if (size % 512)
+				Address += 512;
+
+			header = (FileHeader *)Address;
+			NextInode++;
+		}
+
+		/* TODO: This code can be significantly optimized but good luck understanding it */
+		USTARInode *parent = nullptr;
+		std::vector<USTARInode *> parentStack;
+		std::vector<std::string *> pathStack;
+		for (auto &file : tmpNodes)
+		{
+			if (file->Path == "/") /* This is root / */
+			{
+				parentStack.push_back(file);
+				pathStack.push_back(&file->Path);
+				// debug("root / generated");
+				continue;
+			}
+
+			/* pathStack is never empty */
+
+			if (file->Path.back() == '/') /* This is a directory */
+			{
+				const char *path = file->Path.c_str();
+				size_t length;
+				/* This converts /one/two/path.txt to /one/two/ */
+				cwk_path_get_dirname(path, &length);
+				std::string dirName(path, length);
+
+				/* Check if the directory is at the same level as the current directory */
+				if (dirName == *pathStack.back())
+				{
+					parent = parentStack.back();
+					parentStack.push_back(file);
+					pathStack.push_back(&file->Path);
+					parent->Children.push_back(file);
+					file->Parent = parent;
+					// debug("adding \"%s\" to \"%s\"", file->Path.c_str(), parent->Path.c_str());
+					continue;
+				}
+				else
+				{
+					/* Check if the directory is at a higher level */
+					for (size_t i = 0; i < parentStack.size(); i++)
+					{
+						if (dirName != *pathStack[i])
+							continue;
+
+						/* Adjust vectors */
+						while (!parentStack.empty())
+						{
+							if (dirName == *pathStack.back())
+								break;
+
+							// debug("popping \"%s\"", pathStack.back()->c_str());
+							parentStack.pop_back();
+							pathStack.pop_back();
+						}
+
+						parent = parentStack.back();
+						parentStack.push_back(file);
+						pathStack.push_back(&file->Path);
+						parent->Children.push_back(file);
+						file->Parent = parent;
+						// debug("adding \"%s\" to \"%s\"", file->Path.c_str(), parent->Path.c_str());
+						goto foundEnd;
+					}
+
+					// This is a new directory level
+					parentStack.pop_back();
+					pathStack.pop_back();
+					parent = parentStack.back();
+					parentStack.push_back(file);
+					pathStack.push_back(&file->Path);
+					parent->Children.push_back(file);
+					file->Parent = parent;
+					// debug("adding \"%s\" to \"%s\"", file->Path.c_str(), parent->Path.c_str());
+				foundEnd:
+					continue;
+				}
+			}
+
+			/* From here, it's a file */
+
+			const char *path = file->Path.c_str();
+			size_t length;
+			/* This converts /one/two/path.txt to /one/two/ */
+			cwk_path_get_dirname(path, &length);
+			std::string dirName(path, length);
+
+			/* Check if the file is at the same level as the current directory */
+			if (dirName == *pathStack.back())
+			{
+				parent = parentStack.back();
+				parent->Children.push_back(file);
+				file->Parent = parent;
+				// debug("adding \"%s\" to \"%s\"", file->Path.c_str(), parent->Path.c_str());
+				continue;
+			}
+
+			/* Check if the file is at a higher level */
+			for (size_t i = 0; i < parentStack.size(); i++)
+			{
+				if (dirName != *pathStack[i])
+					continue;
+
+				/* Adjust vectors */
+				while (!parentStack.empty())
+				{
+					if (dirName == *pathStack.back())
+						break;
+
+					// debug("popping \"%s\"", pathStack.back()->c_str());
+					parentStack.pop_back();
+					pathStack.pop_back();
+				}
+
+				parent = parentStack.back();
+				parent->Children.push_back(file);
+				file->Parent = parent;
+				// debug("adding \"%s\" to \"%s\"", file->Path.c_str(), parent->Path.c_str());
+			}
+		}
+
+		std::function<void(vfs::USTAR::USTARInode *, int, const std::string &)> ustarTree = [&](vfs::USTAR::USTARInode *node, int level, const std::string &prefix)
+		{
+			debug("%*s\"%s\"%ld", level * 4, prefix.c_str(), node->Name.c_str(), node->Node.Offset);
+			off_t offset = 2; /* 0 . | 1 .. */
+			for (auto &child : node->Children)
+			{
+#ifdef DEBUG
+				if (offset <= 2)
+				{
+					if (offset == 2)
+						offset = 0;
+					/* Pseudo directories . and .. */
+					USTARInode pseudoDot{};
+					pseudoDot.Node = node->Node;
+					pseudoDot.Name = ".";
+					pseudoDot.Node.Offset = offset++;
+					USTARInode pseudoDDot{};
+					pseudoDDot.Node = node->Parent ? node->Parent->Node : node->Node;
+					pseudoDDot.Name = "..";
+					pseudoDDot.Node.Offset = offset++;
+					ustarTree(&pseudoDot, level + 1, "|-- ");
+					ustarTree(&pseudoDDot, level + 1, "|-- ");
+				}
+#endif
+
+				child->Node.Offset = offset++;
+				ustarTree(child, level + 1, child == node->Children.back() ? "`-- " : "|-- ");
+			}
+		};
+
+		ustarTree(tmpNodes[0], 0, "");
+	}
+}
+
+O2 int __ustar_Lookup(struct Inode *Parent, const char *Name, struct Inode **Result)
+{
+	return ((vfs::USTAR *)Parent->PrivateData)->Lookup(Parent, Name, Result);
+}
+
+O2 int __ustar_Create(struct Inode *Parent, const char *Name, mode_t Mode, struct Inode **Result)
+{
+	return ((vfs::USTAR *)Parent->PrivateData)->Create(Parent, Name, Mode, Result);
+}
+
+O2 ssize_t __ustar_Read(struct Inode *Node, void *Buffer, size_t Size, off_t Offset)
+{
+	return ((vfs::USTAR *)Node->PrivateData)->Read(Node, Buffer, Size, Offset);
+}
+
+O2 ssize_t __ustar_Readdir(struct Inode *Node, struct kdirent *Buffer, size_t Size, off_t Offset, off_t Entries)
+{
+	return ((vfs::USTAR *)Node->PrivateData)->ReadDir(Node, Buffer, Size, Offset, Entries);
+}
+
+O2 int __ustar_SymLink(Inode *Parent, const char *Name, const char *Target, Inode **Result)
+{
+	return ((vfs::USTAR *)Parent->PrivateData)->SymLink(Parent, Name, Target, Result);
+}
+
+O2 ssize_t __ustar_ReadLink(Inode *Node, char *Buffer, size_t Size)
+{
+	return ((vfs::USTAR *)Node->PrivateData)->ReadLink(Node, Buffer, Size);
+}
+
+O2 int __ustar_Stat(struct Inode *Node, kstat *Stat)
+{
+	return ((vfs::USTAR *)Node->PrivateData)->Stat(Node, Stat);
+}
+
+int __ustar_DestroyInode(FileSystemInfo *Info, Inode *Node)
+{
+	((vfs::USTAR::USTARInode *)Node)->Deleted = true;
+	return 0;
+}
+
+int __ustar_Destroy(FileSystemInfo *fsi)
+{
+	assert(fsi->PrivateData);
+	delete (vfs::USTAR *)fsi->PrivateData;
+	delete fsi;
+	return 0;
+}
+
+bool TestAndInitializeUSTAR(uintptr_t Address, size_t Size)
+{
+	vfs::USTAR *ustar = new vfs::USTAR();
+	if (!ustar->TestArchive(Address))
+	{
+		delete ustar;
+		return false;
+	}
+
+	ustar->DeviceID = fs->EarlyReserveDevice();
+	ustar->ReadArchive(Address, Size);
+
+	Inode *initrd = nullptr;
+	ustar->Lookup(nullptr, "/", &initrd);
+	assert(initrd != nullptr);
+
+	FileSystemInfo *fsi = new FileSystemInfo;
+	fsi->Name = "ustar";
+	fsi->RootName = "/";
+	fsi->Flags = I_FLAG_ROOT | I_FLAG_MOUNTPOINT | I_FLAG_CACHE_KEEP;
+	fsi->SuperOps.DeleteInode = __ustar_DestroyInode;
+	fsi->SuperOps.Destroy = __ustar_Destroy;
+	fsi->Ops.Lookup = __ustar_Lookup;
+	fsi->Ops.Create = __ustar_Create;
+	fsi->Ops.Read = __ustar_Read;
+	fsi->Ops.ReadDir = __ustar_Readdir;
+	fsi->Ops.SymLink = __ustar_SymLink;
+	fsi->Ops.ReadLink = __ustar_ReadLink;
+	fsi->Ops.Stat = __ustar_Stat;
+	fsi->PrivateData = ustar;
+	fs->LateRegisterFileSystem(ustar->DeviceID, fsi, initrd);
+
+	fs->AddRoot(initrd);
+	return true;
+}

Kernel/storage/virtual.cpp

@@ -0,0 +1,257 @@
+/*
+	This file is part of Fennix Kernel.
+
+	Fennix Kernel is free software: you can redistribute it and/or
+	modify it under the terms of the GNU General Public License as
+	published by the Free Software Foundation, either version 3 of
+	the License, or (at your option) any later version.
+
+	Fennix Kernel is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <filesystem.hpp>
+
+#include <convert.h>
+#include <printf.h>
+#include <cwalk.h>
+
+#include "../kernel.h"
+
+namespace vfs
+{
+	/*	maj = 0
+		min:
+			0 - <ROOT>
+			1 - /proc/self
+			...
+	*/
+
+	int __vfs_Lookup(struct Inode *_Parent, const char *Name, struct Inode **Result)
+	{
+		vfsInode *Parent = (vfsInode *)_Parent;
+
+		if (!S_ISDIR(Parent->Node.Mode))
+			return -ENOTDIR;
+
+		assert(Parent->Node.Flags & I_FLAG_MOUNTPOINT);
+
+		if (Parent->Children.empty())
+			return -ENOENT;
+
+		off_t offset = 0;
+		for (const auto &Root : Parent->Children)
+		{
+			char rootName[128]{};
+			snprintf(rootName, sizeof(rootName), "\x06root-%ld\x06", offset);
+
+			if (strcmp(rootName, Name) == 0)
+			{
+				*Result = Root;
+				return 0;
+			}
+			offset++;
+		}
+
+		return -ENOENT;
+	}
+
+	int __vfs_Create(struct Inode *Parent, const char *Name, mode_t Mode, struct Inode **Result)
+	{
+		assert(Parent != nullptr);
+		assert(!"Not implemented");
+	}
+
+	/* This implementation is used internally by the kernel, so no "." & ".." */
+	__no_sanitize("alignment")
+		ssize_t __vfs_Readdir(struct Inode *_Node, struct kdirent *Buffer, size_t Size, off_t Offset, off_t Entries)
+	{
+		if (_Node->GetMinor() != 0)
+		{
+			debug("_Node->GetMinor() != 0");
+			return -ENOENT;
+		}
+
+		assert(_Node->Flags & I_FLAG_MOUNTPOINT);
+
+		fixme("maybe wrong implementation of readdir");
+
+		size_t totalSize = 0;
+		off_t entriesSkipped = 0;
+		struct kdirent *ent = nullptr;
+		vfsInode *Node = (vfsInode *)_Node;
+		off_t entries = 0;
+		foreach (const auto &Root in Node->Children)
+		{
+			if (entries >= Entries)
+				break;
+
+			uint16_t reclen = (uint16_t)(offsetof(struct kdirent, d_name) + strlen("root") + 1);
+
+			if (Offset > entriesSkipped)
+			{
+				entriesSkipped++;
+				continue;
+			}
+
+			if (totalSize + reclen >= Size)
+				break;
+
+			ent = (struct kdirent *)((uintptr_t)Buffer + totalSize);
+			ent->d_ino = Root->Index;
+			ent->d_off = Root->Offset;
+			ent->d_reclen = reclen;
+			ent->d_type = IFTODT(Root->Mode);
+			strncpy(ent->d_name, "root", strlen("root"));
+
+			totalSize += reclen;
+			entries++;
+		}
+
+		if (ent)
+			ent->d_off = INT32_MAX;
+
+		if (totalSize + sizeof(struct kdirent) >= Size)
+			return totalSize;
+
+		ent = (struct kdirent *)((uintptr_t)Buffer + totalSize);
+		ent->d_ino = 0;
+		ent->d_off = 0;
+		ent->d_reclen = 0;
+		ent->d_type = DT_UNKNOWN;
+		ent->d_name[0] = '\0';
+		return totalSize;
+	}
+
+	ssize_t __vfs_ReadLink(struct Inode *Node, char *Buffer, size_t Size)
+	{
+		switch (Node->GetMinor())
+		{
+		case 1:
+		{
+			/* FIXME: https://github.com/torvalds/linux/blob/c942a0cd3603e34dd2d7237e064d9318cb7f9654/fs/proc/self.c#L11
+					https://lxr.linux.no/#linux+v3.2.9/fs/proc/base.c#L2482 */
+
+			int ret = snprintf(Buffer, Size, "/proc/%d", thisProcess->ID);
+			debug("ReadLink: %s (%d bytes)", Buffer, ret);
+			return ret;
+		}
+		default:
+			return -ENOENT;
+		}
+	}
+
+	void Virtual::Initialize()
+	{
+		SmartLock(VirtualLock);
+
+		trace("Initializing virtual file system...");
+		uint32_t iFlags = I_FLAG_CACHE_KEEP;
+
+		/* d rwx rwx rwx */
+		mode_t mode = S_IRWXU |
+					  S_IRWXG |
+					  S_IRWXO |
+					  S_IFDIR;
+		FileNode *proc = this->ForceCreate(this->GetRoot(0), "proc", mode);
+		FileNode *var = this->ForceCreate(this->GetRoot(0), "var", mode);
+		FileNode *log = this->ForceCreate(var, "log", mode);
+		proc->Node->Flags = iFlags;
+		log->Node->Flags = iFlags;
+
+		/* l rwx rwx rwx */
+		mode = S_IRWXU |
+			   S_IRWXG |
+			   S_IRWXO |
+			   S_IFLNK;
+		FileNode *self = this->ForceCreate(proc, "self", mode);
+		self->Node->Device = FileSystemRoots->Node.Device;
+		self->Node->SetDevice(0, 1);
+		self->Node->Flags = iFlags;
+	}
+
+	dev_t Virtual::EarlyReserveDevice()
+	{
+		RegisterLock.store(true);
+		size_t len = DeviceMap.size();
+		return len;
+	}
+
+	int Virtual::LateRegisterFileSystem(dev_t Device, FileSystemInfo *fsi, Inode *Root)
+	{
+		auto it = DeviceMap.find(Device);
+		if (it != DeviceMap.end())
+			ReturnLogError(-EEXIST, "Device %d already registered", Device);
+
+		Root->Flags |= I_FLAG_ROOT;
+		FSMountInfo fsmi{.fsi = fsi, .Root = Root};
+		DeviceMap.insert({Device, fsmi});
+		RegisterLock.store(false);
+		return 0;
+	}
+
+	dev_t Virtual::RegisterFileSystem(FileSystemInfo *fsi, Inode *Root)
+	{
+		RegisterLock.store(true);
+		size_t len = DeviceMap.size();
+		Root->Flags |= I_FLAG_ROOT;
+		FSMountInfo fsmi{.fsi = fsi, .Root = Root};
+		DeviceMap.insert({len, fsmi});
+		RegisterLock.store(false);
+		return len;
+	}
+
+	int Virtual::UnregisterFileSystem(dev_t Device)
+	{
+		auto it = DeviceMap.find(Device);
+		if (it == DeviceMap.end())
+			ReturnLogError(-ENOENT, "Device %d not found", Device);
+
+		if (it->second.fsi->SuperOps.Synchronize)
+			it->second.fsi->SuperOps.Synchronize(it->second.fsi, NULL);
+		if (it->second.fsi->SuperOps.Destroy)
+			it->second.fsi->SuperOps.Destroy(it->second.fsi);
+		DeviceMap.erase(it);
+		return 0;
+	}
+
+	Virtual::Virtual()
+	{
+		SmartLock(VirtualLock);
+
+		FileSystemRoots = new vfsInode;
+		FileSystemRoots->Node.Index = -1;
+
+		FileSystemRoots->Node.Mode = S_IRWXU |
+									 S_IRWXG |
+									 S_IROTH | S_IXOTH |
+									 S_IFDIR;
+
+		FileSystemRoots->Node.Flags = I_FLAG_ROOT | I_FLAG_MOUNTPOINT | I_FLAG_CACHE_KEEP;
+
+		FileSystemRoots->Node.Offset = INT32_MAX;
+		FileSystemRoots->Name = "<ROOT>";
+
+		FileSystemInfo *fsi = new FileSystemInfo;
+		fsi->Name = "Virtual Roots";
+		fsi->RootName = "ROOT";
+		fsi->Flags = I_FLAG_ROOT | I_FLAG_MOUNTPOINT | I_FLAG_CACHE_KEEP;
+		fsi->SuperOps = {};
+		fsi->Ops.Lookup = __vfs_Lookup;
+		fsi->Ops.Create = __vfs_Create;
+		fsi->Ops.ReadDir = __vfs_Readdir;
+		fsi->Ops.ReadLink = __vfs_ReadLink;
+
+		FileSystemRoots->Node.Device = this->RegisterFileSystem(fsi, &FileSystemRoots->Node);
+		FileSystemRoots->Node.SetDevice(0, 0);
+	}
+
+	Virtual::~Virtual()
+	{
+	}
+}