Kernel: Add possibiliity to create empty files on Ext2

Big rewrite for Ext2 for more easy and optimized code

kernel/include/kernel/FS/Ext2.h

@@ -81,6 +81,8 @@ namespace Kernel
 			uint16_t free_blocks_count;
 			uint16_t free_inodes_count;
 			uint16_t used_dirs_count;
+			uint8_t __padding[2];
+			uint8_t __reserved[12];
 		};
 
 		struct Inode
@@ -121,16 +123,18 @@ namespace Kernel
 	class Ext2Inode : public Inode
 	{
 	public:
-		virtual uint16_t uid() const override { return m_inode.uid; }
+		virtual uid_t uid() const override { return m_inode.uid; }
-		virtual uint16_t gid() const override { return m_inode.gid; }
+		virtual gid_t gid() const override { return m_inode.gid; }
-		virtual uint32_t size() const override { return m_inode.size; }
+		virtual size_t size() const override { return m_inode.size; }
 
-		virtual Mode mode() const override { return { .mode = m_inode.mode }; }
+		virtual mode_t mode() const override { return m_inode.mode; }
 
 		virtual BAN::StringView name() const override { return m_name; }
 
 		virtual BAN::ErrorOr<size_t> read(size_t, void*, size_t) override;
 
+		virtual BAN::ErrorOr<void> create_file(BAN::StringView, mode_t) override;
+
 		virtual Type type() const override { return Type::Ext2; }
 		virtual bool operator==(const Inode& other) const override;
 
@@ -177,14 +181,23 @@ namespace Kernel
 		BAN::ErrorOr<void> initialize_superblock();
 		BAN::ErrorOr<void> initialize_root_inode();
 
-		BAN::ErrorOr<Ext2::Inode> read_inode(uint32_t);
+		BAN::ErrorOr<uint32_t> create_inode(const Ext2::Inode&);
+		BAN::ErrorOr<void> delete_inode(uint32_t);
+		BAN::ErrorOr<void> resize_inode(uint32_t, size_t);
+
 		BAN::ErrorOr<BAN::Vector<uint8_t>> read_block(uint32_t);
 		BAN::ErrorOr<void> write_block(uint32_t, BAN::Span<const uint8_t>);
 
-		BAN::ErrorOr<Ext2::BlockGroupDescriptor> read_block_group_descriptor(uint32_t);
-
 		const Ext2::Superblock& superblock() const { return m_superblock; }
 
+		struct BlockLocation
+		{
+			uint32_t block;
+			uint32_t offset;
+		};
+		BAN::ErrorOr<BlockLocation> locate_inode(uint32_t);
+		BlockLocation locate_block_group_descriptior(uint32_t);
+
 		uint32_t block_size() const { return 1024 << superblock().log_block_size; }
 
 	private:

kernel/include/kernel/FS/Inode.h

@@ -4,34 +4,32 @@
 #include <BAN/String.h>
 #include <BAN/Vector.h>
 
+#include <sys/types.h>
+
 namespace Kernel
 {
 
 	class Inode : public BAN::RefCounted<Inode>
 	{
 	public:
-		union Mode
+		enum Mode : mode_t
 		{
-			struct
+			IXOTH = 0x0001,
-			{
+			IWOTH = 0x0002,
-				uint16_t IXOTH : 1; // 0x0001
+			IROTH = 0x0004,
-				uint16_t IWOTH : 1; // 0x0002
+			IXGRP = 0x0008,
-				uint16_t IROTH : 1; // 0x0004
+			IWGRP = 0x0010,
-				uint16_t IXGRP : 1; // 0x0008
+			IRGRP = 0x0020,
-				uint16_t IWGRP : 1; // 0x0010
+			IXUSR = 0x0040,
-				uint16_t IRGRP : 1; // 0x0020
+			IWUSR = 0x0080,
-				uint16_t IXUSR : 1; // 0x0040
+			IRUSR = 0x0100,
-				uint16_t IWUSR : 1; // 0x0080
+			ISVTX = 0x0200,
-				uint16_t IRUSR : 1; // 0x0100
+			ISGID = 0x0400,
-				uint16_t ISVTX : 1; // 0x0200
+			ISUID = 0x0800,
-				uint16_t ISGID : 1; // 0x0400
+			IFIFO = 0x1000,
-				uint16_t ISUID : 1; // 0x0800
+			IFCHR = 0x2000,
-				uint16_t IFIFO : 1; // 0x1000
+			IFDIR = 0x4000,
-				uint16_t IFCHR : 1; // 0x2000
+			IFREG = 0x8000,
-				uint16_t IFDIR : 1; // 0x4000
-				uint16_t IFREG : 1; // 0x8000
-			};
-			uint16_t mode;
 		};
 
 		enum class Type
@@ -42,14 +40,14 @@ namespace Kernel
 	public:
 		virtual ~Inode() {}
 
-		bool ifdir() const { return mode().IFDIR; }
+		bool ifdir() const { return mode() & Mode::IFDIR; }
-		bool ifreg() const { return mode().IFREG; }
+		bool ifreg() const { return mode() & Mode::IFREG; }
 
-		virtual uint16_t uid() const = 0;
+		virtual uid_t uid() const = 0;
-		virtual uint16_t gid() const = 0;
+		virtual gid_t gid() const = 0;
-		virtual uint32_t size() const = 0;
+		virtual size_t size() const = 0;
 
-		virtual Mode mode() const = 0;
+		virtual mode_t mode() const = 0;
 
 		virtual BAN::StringView name() const = 0;
 
@@ -58,6 +56,8 @@ namespace Kernel
 
 		virtual BAN::ErrorOr<size_t> read(size_t, void*, size_t) = 0;
 
+		virtual BAN::ErrorOr<void> create_file(BAN::StringView, mode_t) = 0;
+
 		virtual Type type() const = 0;
 		virtual bool operator==(const Inode&) const = 0;
 

kernel/include/kernel/Process.h

@@ -29,6 +29,7 @@ namespace Kernel
 		BAN::ErrorOr<int> open(BAN::StringView, int);
 		BAN::ErrorOr<void> close(int);
 		BAN::ErrorOr<size_t> read(int, void*, size_t);
+		BAN::ErrorOr<void> creat(BAN::StringView, mode_t);
 
 		BAN::StringView working_directory() const { return m_working_directory; }
 		BAN::ErrorOr<void> set_working_directory(BAN::StringView);

kernel/kernel/FS/Ext2.cpp

@@ -1,8 +1,10 @@
 #include <BAN/ScopeGuard.h>
 #include <BAN/StringView.h>
 #include <kernel/FS/Ext2.h>
+#include <kernel/RTC.h>
 
 #define EXT2_DEBUG_PRINT 0
+#define VERIFY_INODE_EXISTANCE 1
 
 namespace Kernel
 {
@@ -134,12 +136,26 @@ namespace Kernel
 			RESERVED_FL		= 0x80000000,
 		};
 
+		enum FileType
+		{
+			UNKNOWN = 0,
+			REG_FILE = 1,
+			DIR = 2,
+			CHRDEV = 3,
+			BLKDEV = 4,
+			FIFO = 5,
+			SOCK = 6,
+			SYMLINK = 7,
+		};
+
 	}
 
-	BAN::ErrorOr<BAN::RefPtr<Inode>> Ext2Inode::create(Ext2FS& fs, uint32_t inode, BAN::StringView name)
+	BAN::ErrorOr<BAN::RefPtr<Inode>> Ext2Inode::create(Ext2FS& fs, uint32_t inode_inode, BAN::StringView name)
 	{
-		Ext2::Inode ext2_inode = TRY(fs.read_inode(inode));
+		auto inode_location = TRY(fs.locate_inode(inode_inode));
-		Ext2Inode* result = new Ext2Inode(fs, ext2_inode, name, inode);
+		auto inode_buffer = TRY(fs.read_block(inode_location.block));
+		auto& inode = *(Ext2::Inode*)(inode_buffer.data() + inode_location.offset);
+		Ext2Inode* result = new Ext2Inode(fs, inode, name, inode_inode);
 		if (result == nullptr)
 			return BAN::Error::from_errno(ENOMEM);
 		return BAN::RefPtr<Inode>::adopt(result);
@@ -250,6 +266,87 @@ namespace Kernel
 		return n_read;
 	}
 
+	BAN::ErrorOr<void> Ext2Inode::create_file(BAN::StringView name, mode_t mode)
+	{
+		if (!ifdir())
+			return BAN::Error::from_errno(ENOTDIR);
+
+		if (name.size() > 255)
+			return BAN::Error::from_errno(ENAMETOOLONG);
+
+		auto error_or = directory_find_impl(name);
+		if (!error_or.is_error())
+			return BAN::Error::from_errno(EEXISTS);
+		if (error_or.error().get_error_code() != ENOENT)
+			return error_or.error();
+
+		uint64_t current_time = RTC::get_unix_time();
+
+		Ext2::Inode ext2_inode;
+		ext2_inode.mode			= mode;
+		ext2_inode.uid			= 0;
+		ext2_inode.size			= 0;
+		ext2_inode.atime 		= current_time;
+		ext2_inode.ctime 		= current_time;
+		ext2_inode.mtime 		= current_time;
+		ext2_inode.dtime 		= current_time;
+		ext2_inode.gid			= 0;
+		ext2_inode.links_count	= 1;
+		ext2_inode.blocks		= 0;
+		ext2_inode.flags		= 0;
+		ext2_inode.osd1			= 0;
+		memset(ext2_inode.block, 0, sizeof(ext2_inode.block));
+		ext2_inode.generation	= 0;
+		ext2_inode.file_acl		= 0;
+		ext2_inode.dir_acl		= 0;
+		ext2_inode.faddr		= 0;
+		memset(ext2_inode.osd2, 0, sizeof(ext2_inode.osd2));
+
+		uint32_t inode_index = TRY(m_fs.create_inode(ext2_inode));
+
+		// Insert inode to this directory
+		uint32_t data_block_count = m_inode.blocks / (2 << m_fs.superblock().log_block_size);
+		uint32_t block_index = TRY(data_block_index(data_block_count - 1));
+		auto block_data = TRY(m_fs.read_block(block_index));
+
+		const uint8_t* block_data_end = block_data.data() + block_data.size();
+		const uint8_t* entry_addr = block_data.data();
+
+		uint32_t needed_entry_len = sizeof(Ext2::LinkedDirectoryEntry) + name.size();
+
+		bool insered = false;
+		while (entry_addr < block_data_end)
+		{
+			auto& entry = *(Ext2::LinkedDirectoryEntry*)entry_addr;
+
+			if (needed_entry_len <= entry.rec_len - entry.name_len - sizeof(Ext2::LinkedDirectoryEntry))
+			{
+				entry.rec_len = sizeof(Ext2::LinkedDirectoryEntry) + entry.name_len;
+				if (uint32_t rem = entry.rec_len % 4)
+					entry.rec_len += 4 - rem;
+
+				auto& new_entry = *(Ext2::LinkedDirectoryEntry*)(entry_addr + entry.rec_len);
+				new_entry.inode = inode_index;
+				new_entry.rec_len = block_data_end - (uint8_t*)&new_entry;
+				new_entry.name_len = name.size();
+				new_entry.file_type = Ext2::Enum::REG_FILE;
+				memcpy(new_entry.name, name.data(), name.size());
+
+				TRY(m_fs.write_block(block_index, block_data.span()));
+
+				insered = true;
+				break;
+			}
+			entry_addr += entry.rec_len;
+		}
+
+		// FIXME: If an entry cannot completely fit in one block, it must be pushed to the
+		//        next data block and the rec_len of the previous entry properly adjusted.
+		ASSERT(insered);
+
+		return {};
+	}
+
 	BAN::ErrorOr<BAN::RefPtr<Inode>> Ext2Inode::directory_find_impl(BAN::StringView file_name)
 	{
 		if (!ifdir())
@@ -350,7 +447,7 @@ namespace Kernel
 		}
 
 		if (m_superblock.magic != 0xEF53)
-			return BAN::Error::from_c_string("Not a ext2 filesystem");
+			return BAN::Error::from_c_string("Not an ext2 filesystem");
 
 		if (m_superblock.rev_level < 1)
 		{
@@ -359,6 +456,11 @@ namespace Kernel
 			m_superblock.inode_size = 128;
 		}
 
+		uint32_t number_of_block_groups       = BAN::Math::div_round_up(superblock().inodes_count, superblock().inodes_per_group);
+		uint32_t number_of_block_groups_check = BAN::Math::div_round_up(superblock().blocks_count, superblock().blocks_per_group);
+		if (number_of_block_groups != number_of_block_groups_check)
+			return BAN::Error::from_c_string("Ambiguous number of block groups");
+
 		ASSERT(!(m_superblock.feature_incompat & Ext2::Enum::FEATURE_INCOMPAT_COMPRESSION));
 		//ASSERT(!(m_superblock.feature_incompat & Ext2::Enum::FEATURE_INCOMPAT_FILETYPE));
 		ASSERT(!(m_superblock.feature_incompat & Ext2::Enum::FEATURE_INCOMPAT_JOURNAL_DEV));
@@ -390,38 +492,39 @@ namespace Kernel
 		return {};
 	}
 
-	BAN::ErrorOr<uint32_t> Ext2FS::find_free_inode_index()
+	BAN::ErrorOr<uint32_t> Ext2FS::create_inode(const Ext2::Inode& ext2_inode)
 	{
-		ASSERT(false);
+		ASSERT(ext2_inode.size == 0);
-		return 0;
-	}
 
-	BAN::ErrorOr<Ext2::Inode> Ext2FS::read_inode(uint32_t inode_index)
+		uint32_t number_of_block_groups = BAN::Math::div_round_up(superblock().inodes_count, superblock().inodes_per_group);
-	{
+		for (uint32_t group = 0; group < number_of_block_groups; group++)
-		if (inode_index >= superblock().inodes_count)
+		{
-			return BAN::Error::from_format("Asked to read inode {}, but only {} exist in the filesystem", inode_index, superblock().inodes_count);
+			auto bgd_location = this->locate_block_group_descriptior(group);
+			auto bgd_buffer = TRY(this->read_block(bgd_location.block));
 
-		uint32_t block_size = this->block_size();
+			auto& bgd = *(Ext2::BlockGroupDescriptor*)(bgd_buffer.data() + bgd_location.offset);
+			if (bgd.free_inodes_count == 0)
+				continue;
 
-		uint32_t inode_block_group = (inode_index - 1) / superblock().inodes_per_group;
+			auto inode_bitmap = TRY(read_block(bgd.inode_bitmap));
-		uint32_t local_inode_index = (inode_index - 1) % superblock().inodes_per_group;
+			for (uint32_t inode_offset = 0; inode_offset < superblock().inodes_per_group; inode_offset++)
+			{
+				uint32_t byte = inode_offset / 8;
+				uint32_t bit  = inode_offset % 8;
+				if ((inode_bitmap[byte] & (1 << bit)) == 0)
+				{
+					inode_bitmap[byte] |= (1 << bit);
+					TRY(write_block(bgd.inode_bitmap, inode_bitmap.span()));
 
-		uint32_t inode_table_byte_offset = (local_inode_index * superblock().inode_size);
+					bgd.free_inodes_count--;
+					TRY(write_block(bgd_location.block, bgd_buffer.span()));
 
-		auto block_group_descriptor = TRY(read_block_group_descriptor(inode_block_group));
+					return group * superblock().inodes_per_group + inode_offset + 1;
+				}
+			}
+		}
 
-		uint32_t inode_block = block_group_descriptor.inode_table + inode_table_byte_offset / block_size;
+		return BAN::Error::from_c_string("No free inodes available in the whole filesystem");
-		auto inode_block_buffer = TRY(read_block(inode_block));
-
-		Ext2::Inode ext2_inode;
-		memcpy(&ext2_inode, inode_block_buffer.data() + inode_table_byte_offset % block_size, sizeof(Ext2::Inode));
-		return ext2_inode;
-	}
-
-	BAN::ErrorOr<void> Ext2FS::write_inode(uint32_t inode_index, const Ext2::Inode& ext2_inode)
-	{
-		ASSERT(false);
-		return {};
 	}
 
 	BAN::ErrorOr<BAN::Vector<uint8_t>> Ext2FS::read_block(uint32_t block)
@@ -439,40 +542,60 @@ namespace Kernel
 
 	BAN::ErrorOr<void> Ext2FS::write_block(uint32_t block, BAN::Span<const uint8_t> data)
 	{
-		const uint32_t sector_size = m_partition.device().sector_size();
+		uint32_t sector_size = m_partition.device().sector_size();
-		const uint32_t block_size = 1024 << m_superblock.log_block_size;
+		uint32_t block_size = this->block_size();
-		ASSERT(block_size % sector_size == 0);
+		uint32_t sectors_per_block = block_size / sector_size;
-		ASSERT(data.size() <= block_size);
-		const uint32_t sectors_per_block = block_size / sector_size;
 
+		ASSERT(data.size() <= block_size);
 		TRY(m_partition.write_sectors(block * sectors_per_block, sectors_per_block, data.data()));
 
 		return {};
 	}
 
-	BAN::ErrorOr<Ext2::BlockGroupDescriptor> Ext2FS::read_block_group_descriptor(uint32_t index)
+	BAN::ErrorOr<Ext2FS::BlockLocation> Ext2FS::locate_inode(uint32_t inode_index)
-	{	
+	{
+		if (inode_index >= superblock().inodes_count)
+			return BAN::Error::from_format("Asked to read inode {}, but only {} exist in the filesystem", inode_index, superblock().inodes_count);
+
 		uint32_t block_size = this->block_size();
 
-		uint32_t number_of_block_groups       = BAN::Math::div_round_up(superblock().inodes_count, superblock().inodes_per_group);
+		uint32_t inode_block_group = (inode_index - 1) / superblock().inodes_per_group;
-		uint32_t number_of_block_groups_check = BAN::Math::div_round_up(superblock().blocks_count, superblock().blocks_per_group);
+		uint32_t local_inode_index = (inode_index - 1) % superblock().inodes_per_group;
-		if (number_of_block_groups != number_of_block_groups_check)
-			return BAN::Error::from_c_string("Ambiguous number of block groups");
-		
-		ASSERT(index < number_of_block_groups);
 
-		// NOTE: We use 32 because we cannot use the sizeof(Ext2::BlockGroupDescriptor) since I have
+		uint32_t inode_table_byte_offset = (local_inode_index * superblock().inode_size);
-		//       left out 14 bytes of padding/reserved memory from the end of the structure
-		uint32_t block_group_descriptor_byte_offset = 32u * index;
 
-		uint32_t block_group_descriptor_block = superblock().first_data_block + block_group_descriptor_byte_offset / block_size + 1;
+		auto bgd_location = locate_block_group_descriptior(inode_block_group);
+		auto bgd_buffer = TRY(read_block(bgd_location.block));
+		auto& bgd = *(Ext2::BlockGroupDescriptor*)(bgd_buffer.data() + bgd_location.offset);
 
-		auto block_data = TRY(read_block(block_group_descriptor_block));
+#if VERIFY_INODE_EXISTANCE
+		ASSERT(superblock().inodes_per_group <= block_size * 8);
+		auto inode_bitmap = TRY(read_block(bgd.inode_bitmap));
+		uint32_t byte = local_inode_index / 8;
+		uint32_t bit  = local_inode_index % 8;
+		ASSERT(inode_bitmap[byte] & (1 << bit));
+#endif
 
-		Ext2::BlockGroupDescriptor result;
+		BlockLocation location;
-		memcpy(&result, block_data.data() + block_group_descriptor_byte_offset % block_size, sizeof(Ext2::BlockGroupDescriptor));
+		location.block = bgd.inode_table + inode_table_byte_offset / block_size;
+		location.offset = inode_table_byte_offset % block_size;
+		return location;
+	}
 
-		return result;
+	Ext2FS::BlockLocation Ext2FS::locate_block_group_descriptior(uint32_t group_index)
+	{
+		uint32_t block_size = this->block_size();
+
+		uint32_t block_group_count = BAN::Math::div_round_up(superblock().inodes_count, superblock().inodes_per_group);
+		ASSERT(group_index < block_group_count);
+
+		uint32_t bgd_byte_offset = sizeof(Ext2::BlockGroupDescriptor) * group_index;
+		uint32_t bgd_table_block = superblock().first_data_block + (bgd_byte_offset / block_size) + 1;
+
+		BlockLocation location;
+		location.block  = bgd_table_block + (bgd_byte_offset / block_size);
+		location.offset =					(bgd_byte_offset % block_size);
+		return location;
 	}
 
 }

kernel/kernel/Process.cpp

@@ -72,6 +72,18 @@ namespace Kernel
 		return n_read;
 	}
 
+	BAN::ErrorOr<void> Process::creat(BAN::StringView path, mode_t mode)
+	{
+		auto absolute_path = TRY(absolute_path_of(path));
+		while (absolute_path.sv().back() != '/')
+			absolute_path.pop_back();
+		auto parent_inode = TRY(VirtualFileSystem::get().file_from_absolute_path(absolute_path));
+		if (path.count('/') > 0)
+			return BAN::Error::from_c_string("You can only create files to current working directory");
+		TRY(parent_inode.inode->create_file(path, mode));
+		return {};
+	}
+
 	Inode& Process::inode_for_fd(int fd)
 	{
 		MUST(validate_fd(fd));

kernel/kernel/Shell.cpp

@@ -364,19 +364,19 @@ argument_done:
 			auto& directory = Process::current()->inode_for_fd(fd);
 			auto inodes = TRY(directory.directory_inodes());
 
-			auto mode_string = [](Inode::Mode mode)
+			auto mode_string = [](mode_t mode)
 			{
 				static char buffer[11] {};
-				buffer[0] = mode.IFDIR ? 'd' : '-';
+				buffer[0] = (mode & Inode::Mode::IFDIR) ? 'd' : '-';
-				buffer[1] = mode.IRUSR ? 'r' : '-';
+				buffer[1] = (mode & Inode::Mode::IRUSR) ? 'r' : '-';
-				buffer[2] = mode.IWUSR ? 'w' : '-';
+				buffer[2] = (mode & Inode::Mode::IWUSR) ? 'w' : '-';
-				buffer[3] = mode.IXUSR ? 'x' : '-';
+				buffer[3] = (mode & Inode::Mode::IXUSR) ? 'x' : '-';
-				buffer[4] = mode.IRGRP ? 'r' : '-';
+				buffer[4] = (mode & Inode::Mode::IRGRP) ? 'r' : '-';
-				buffer[5] = mode.IWGRP ? 'w' : '-';
+				buffer[5] = (mode & Inode::Mode::IWGRP) ? 'w' : '-';
-				buffer[6] = mode.IXGRP ? 'x' : '-';
+				buffer[6] = (mode & Inode::Mode::IXGRP) ? 'x' : '-';
-				buffer[7] = mode.IROTH ? 'r' : '-';
+				buffer[7] = (mode & Inode::Mode::IROTH) ? 'r' : '-';
-				buffer[8] = mode.IWOTH ? 'w' : '-';
+				buffer[8] = (mode & Inode::Mode::IWOTH) ? 'w' : '-';
-				buffer[9] = mode.IXOTH ? 'x' : '-';
+				buffer[9] = (mode & Inode::Mode::IXOTH) ? 'x' : '-';
 				return (const char*)buffer;
 			};
 
@@ -413,6 +413,12 @@ argument_done:
 			TRY(Process::current()->set_working_directory(path));
 			TRY(update_prompt());
 		}
+		else if (arguments.front() == "touch")
+		{
+			if (arguments.size() != 2)
+				return BAN::Error::from_c_string("usage 'touch path'");
+			TRY(Process::current()->creat(arguments[1], 0));
+		}
 		else if (arguments.front() == "cksum")
 		{
 			if (arguments.size() < 2)