BAN/include/BAN/Math.h

@@ -102,4 +102,22 @@ namespace BAN::Math
 		return result;
 	}
 
+	template<integral T>
+	inline constexpr T little_endian_to_host(const uint8_t* bytes)
+	{
+		T result = 0;
+		for (size_t i = 0; i < sizeof(T); i++)
+			result |= (T)bytes[i] << (i * 8);
+		return result;
+	}
+
+	template<integral T>
+	inline constexpr T big_endian_to_host(const uint8_t* bytes)
+	{
+		T result = 0;
+		for (size_t i = 0; i < sizeof(T); i++)
+			result |= (T)bytes[i] << (8 * (sizeof(T) - i - 1));
+		return result;
+	}
+
 }

LibELF/LibELF/LoadableELF.cpp

@@ -124,8 +124,6 @@ namespace LibELF
 				dprintln("Invalid program header");
 				return BAN::Error::from_errno(EINVAL);
 			}
-
-			m_virtual_page_count += BAN::Math::div_round_up<size_t>((pheader.p_vaddr % PAGE_SIZE) + pheader.p_memsz, PAGE_SIZE);
 		}
 
 		return {};

LibELF/include/LibELF/LoadableELF.h

@@ -33,8 +33,6 @@ namespace LibELF
 
 		BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> clone(Kernel::PageTable&);
 
-		size_t virtual_page_count() const { return m_virtual_page_count; }
-
 	private:
 		LoadableELF(Kernel::PageTable&, BAN::RefPtr<Kernel::Inode>);
 		BAN::ErrorOr<void> initialize();
@@ -44,7 +42,6 @@ namespace LibELF
 		Kernel::PageTable&					m_page_table;
 		ElfNativeFileHeader					m_file_header;
 		BAN::Vector<ElfNativeProgramHeader>	m_program_headers;
-		size_t m_virtual_page_count = 0;
 	};
 
 }

kernel/CMakeLists.txt

@@ -24,8 +24,6 @@ set(KERNEL_SOURCES
 	kernel/FS/Ext2/Inode.cpp
 	kernel/FS/Inode.cpp
 	kernel/FS/Pipe.cpp
-	kernel/FS/ProcFS/FileSystem.cpp
-	kernel/FS/ProcFS/Inode.cpp
 	kernel/FS/RamFS/FileSystem.cpp
 	kernel/FS/RamFS/Inode.cpp
 	kernel/FS/VirtualFileSystem.cpp

kernel/include/kernel/Device/Device.h

@@ -25,9 +25,9 @@ namespace Kernel
 	{
 	protected:
 		BlockDevice(mode_t mode, uid_t uid, gid_t gid)
-			: Device(mode, uid, gid)
+			: Device(Mode::IFBLK | mode, uid, gid)
 		{
-			m_inode_info.mode |= Inode::Mode::IFBLK;
+			ASSERT(Device::mode().ifblk());
 		}
 	};
 
@@ -35,9 +35,9 @@ namespace Kernel
 	{
 	protected:
 		CharacterDevice(mode_t mode, uid_t uid, gid_t gid)
-			: Device(mode, uid, gid)
+			: Device(Mode::IFCHR | mode, uid, gid)
 		{
-			m_inode_info.mode |= Inode::Mode::IFCHR;
+			ASSERT(Device::mode().ifchr());
 		}
 	};
 

kernel/include/kernel/FS/Inode.h

@@ -89,7 +89,6 @@ namespace Kernel
 		BAN::ErrorOr<BAN::RefPtr<Inode>> find_inode(BAN::StringView);
 		BAN::ErrorOr<void> list_next_inodes(off_t, DirectoryEntryList*, size_t);
 		BAN::ErrorOr<void> create_file(BAN::StringView, mode_t, uid_t, gid_t);
-		BAN::ErrorOr<void> delete_inode(BAN::StringView);
 
 		// Link API
 		BAN::ErrorOr<BAN::String> link_target();
@@ -105,7 +104,6 @@ namespace Kernel
 		virtual BAN::ErrorOr<BAN::RefPtr<Inode>> find_inode_impl(BAN::StringView)				{ return BAN::Error::from_errno(ENOTSUP); }
 		virtual BAN::ErrorOr<void> list_next_inodes_impl(off_t, DirectoryEntryList*, size_t)	{ return BAN::Error::from_errno(ENOTSUP); }
 		virtual BAN::ErrorOr<void> create_file_impl(BAN::StringView, mode_t, uid_t, gid_t)		{ return BAN::Error::from_errno(ENOTSUP); }
-		virtual BAN::ErrorOr<void> delete_inode_impl(BAN::StringView)							{ return BAN::Error::from_errno(ENOTSUP); }
 
 		// Link API
 		virtual BAN::ErrorOr<BAN::String> link_target_impl()				{ return BAN::Error::from_errno(ENOTSUP); }

kernel/include/kernel/FS/ProcFS/FileSystem.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <kernel/FS/RamFS/FileSystem.h>
-#include <kernel/FS/RamFS/Inode.h>
-#include <kernel/Process.h>
-
-namespace Kernel
-{
-
-	class ProcFileSystem final : public RamFileSystem
-	{
-	public:
-		static void initialize();
-		static ProcFileSystem& get();
-
-		BAN::ErrorOr<void> on_process_create(Process&);
-		void on_process_delete(Process&);
-
-	private:
-		ProcFileSystem(size_t size);
-
-	private:
-		BAN::RefPtr<RamDirectoryInode> m_root_inode;
-	};
-
-}

kernel/include/kernel/FS/ProcFS/Inode.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#include <kernel/FS/RamFS/FileSystem.h>
-#include <kernel/FS/RamFS/Inode.h>
-#include <kernel/Process.h>
-
-namespace Kernel
-{
-
-	class ProcPidInode final : public RamDirectoryInode
-	{
-	public:
-		static BAN::ErrorOr<BAN::RefPtr<ProcPidInode>> create(Process&, RamFileSystem&, mode_t, uid_t, gid_t);
-		~ProcPidInode() = default;
-
-	private:
-		ProcPidInode(Process&, RamFileSystem&, const FullInodeInfo&);
-
-	private:
-		Process& m_process;
-	};
-
-	class ProcMemInode final : public RamInode
-	{
-	public:
-		static BAN::ErrorOr<BAN::RefPtr<ProcMemInode>> create(Process&, RamFileSystem&, mode_t, uid_t, gid_t);
-		~ProcMemInode() = default;
-
-	protected:
-		virtual BAN::ErrorOr<size_t> read_impl(off_t, void*, size_t) override;
-
-		// You may not write here and this is always non blocking
-		virtual BAN::ErrorOr<size_t> write_impl(off_t, const void*, size_t)	override	{ return BAN::Error::from_errno(EINVAL); }
-		virtual BAN::ErrorOr<void> truncate_impl(size_t) override						{ return BAN::Error::from_errno(EINVAL); }
-		virtual bool has_data_impl() const override										{ return true; }
-
-	private:
-		ProcMemInode(Process&, RamFileSystem&, const FullInodeInfo&);
-	
-	private:
-		Process& m_process;
-	};
-
-}

kernel/include/kernel/FS/RamFS/Inode.h

@@ -12,6 +12,7 @@ namespace Kernel
 	class RamInode : public Inode
 	{
 	public:
+		static BAN::ErrorOr<BAN::RefPtr<RamInode>> create(RamFileSystem&, mode_t, uid_t, gid_t);
 		virtual ~RamInode() = default;
 
 		virtual ino_t		ino()		const override { return m_inode_info.ino; }
@@ -30,10 +31,16 @@ namespace Kernel
 
 		void add_link() { m_inode_info.nlink++; }
 
+	protected:
+		RamInode(RamFileSystem& fs, mode_t, uid_t, gid_t);
+
+		virtual BAN::ErrorOr<size_t> read_impl(off_t, void*, size_t) override;
+		virtual BAN::ErrorOr<size_t> write_impl(off_t, const void*, size_t) override;
+		virtual BAN::ErrorOr<void> truncate_impl(size_t) override;
+
 	protected:
 		struct FullInodeInfo
 		{
-			FullInodeInfo(RamFileSystem&, mode_t, uid_t, gid_t);
 			ino_t		ino;
 			mode_t		mode;
 			nlink_t		nlink;
@@ -49,38 +56,16 @@ namespace Kernel
 			dev_t		rdev;
 		};
 
-		RamInode(RamFileSystem& fs, const FullInodeInfo& inode_info)
-			: m_fs(fs)
-			, m_inode_info(inode_info)
-		{
-			ASSERT((inode_info.mode & Inode::Mode::TYPE_MASK) == 0);
-		}
-
 	protected:
 		RamFileSystem& m_fs;
 		FullInodeInfo m_inode_info;
-	};
 
-	class RamFileInode : public RamInode
-	{
-	public:
-		static BAN::ErrorOr<BAN::RefPtr<RamFileInode>> create(RamFileSystem&, mode_t, uid_t, gid_t);
-		~RamFileInode() = default;
-
-	protected:
-		RamFileInode(RamFileSystem&, const FullInodeInfo&);
-
-		virtual BAN::ErrorOr<size_t> read_impl(off_t, void*, size_t) override;
-		virtual BAN::ErrorOr<size_t> write_impl(off_t, const void*, size_t) override;
-		virtual BAN::ErrorOr<void> truncate_impl(size_t) override;
-
-	private:
 		BAN::Vector<uint8_t> m_data;
 
 		friend class RamFileSystem;
 	};
 
-	class RamDirectoryInode : public RamInode
+	class RamDirectoryInode final : public RamInode
 	{
 	public:
 		static BAN::ErrorOr<BAN::RefPtr<RamDirectoryInode>> create(RamFileSystem&, ino_t parent, mode_t, uid_t, gid_t);
@@ -89,12 +74,12 @@ namespace Kernel
 		BAN::ErrorOr<void> add_inode(BAN::StringView, BAN::RefPtr<RamInode>);
 
 	protected:
-		RamDirectoryInode(RamFileSystem&, const FullInodeInfo&, ino_t parent);
-
 		virtual BAN::ErrorOr<BAN::RefPtr<Inode>> find_inode_impl(BAN::StringView) override;
 		virtual BAN::ErrorOr<void> list_next_inodes_impl(off_t, DirectoryEntryList*, size_t) override;
 		virtual BAN::ErrorOr<void> create_file_impl(BAN::StringView, mode_t, uid_t, gid_t) override;
-		virtual BAN::ErrorOr<void> delete_inode_impl(BAN::StringView) override;
+
+	private:
+		RamDirectoryInode(RamFileSystem&, ino_t parent, mode_t, uid_t, gid_t);
 
 	private:
 		static constexpr size_t m_name_max = NAME_MAX;
@@ -103,12 +88,11 @@ namespace Kernel
 			char name[m_name_max + 1];
 			size_t name_len = 0;
 			ino_t ino;
-			uint8_t type;
 		};
 
 	private:
 		BAN::Vector<Entry> m_entries;
-		const ino_t m_parent;
+		ino_t m_parent;
 
 		friend class RamFileSystem;
 	};
@@ -127,7 +111,7 @@ namespace Kernel
 		virtual BAN::ErrorOr<BAN::String> link_target_impl() override;
 
 	private:
-		RamSymlinkInode(RamFileSystem&, const FullInodeInfo&, BAN::String&&);
+		RamSymlinkInode(RamFileSystem&, mode_t, uid_t, gid_t);
 
 	private:
 		BAN::String m_target;

kernel/include/kernel/Memory/MemoryRegion.h

@@ -37,8 +37,6 @@ namespace Kernel
 		size_t size() const { return m_size; }
 		vaddr_t vaddr() const { return m_vaddr; }
 
-		size_t virtual_page_count() const { return BAN::Math::div_round_up<size_t>(m_size, PAGE_SIZE); }
-
 		// Returns error if no memory was available
 		// Returns true if page was succesfully allocated
 		// Returns false if page was already allocated

kernel/include/kernel/Process.h

@@ -13,7 +13,6 @@
 #include <kernel/Terminal/TTY.h>
 #include <kernel/Thread.h>
 
-#include <sys/banan-os.h>
 #include <sys/mman.h>
 #include <termios.h>
 
@@ -139,8 +138,6 @@ namespace Kernel
 
 		PageTable& page_table() { return m_page_table ? *m_page_table : PageTable::kernel(); }
 
-		void get_meminfo(proc_meminfo_t*) const;
-
 		bool is_userspace() const { return m_is_userspace; }
 		const userspace_info_t& userspace_info() const { return m_userspace_info; }
 

kernel/include/kernel/Thread.h

@@ -83,8 +83,6 @@ namespace Kernel
 
 		bool is_userspace() const { return m_is_userspace; }
 
-		size_t virtual_page_count() const { return m_stack->size() / PAGE_SIZE; }
-
 #if __enable_sse
 		void save_sse() { asm volatile("fxsave %0" :: "m"(m_sse_storage)); }
 		void load_sse() { asm volatile("fxrstor %0" :: "m"(m_sse_storage)); }

kernel/kernel/Device/Device.cpp

@@ -5,7 +5,7 @@ namespace Kernel
 {
 
 	Device::Device(mode_t mode, uid_t uid, gid_t gid)
-		: RamInode(DevFileSystem::get(), FullInodeInfo(DevFileSystem::get(), mode, uid, gid))
+		: RamInode(DevFileSystem::get(), mode, uid, gid)
 	{ }
 
 }

kernel/kernel/FS/DevFS/FileSystem.cpp

@@ -19,7 +19,7 @@ namespace Kernel
 		s_instance = new DevFileSystem(1024 * 1024);
 		ASSERT(s_instance);
 
-		auto root_inode = MUST(RamDirectoryInode::create(*s_instance, 0, 0755, 0, 0));
+		auto root_inode = MUST(RamDirectoryInode::create(*s_instance, 0, Inode::Mode::IFDIR | 0755, 0, 0));
 		MUST(s_instance->set_root_inode(root_inode));
 
 		s_instance->add_device("null", MUST(NullDevice::create(0666, 0, 0)));

kernel/kernel/FS/Ext2/Inode.cpp

@@ -291,7 +291,6 @@ namespace Kernel
 				if (entry.inode)
 				{
 					ptr->dirent.d_ino = entry.inode;
-					ptr->dirent.d_type = entry.file_type;
 					ptr->rec_len = sizeof(DirectoryEntry) + entry.name_len + 1;
 					memcpy(ptr->dirent.d_name, entry.name, entry.name_len);
 					ptr->dirent.d_name[entry.name_len] = '\0';

kernel/kernel/FS/Inode.cpp

@@ -84,15 +84,6 @@ namespace Kernel
 		return create_file_impl(name, mode, uid, gid);
 	}
 
-	BAN::ErrorOr<void> Inode::delete_inode(BAN::StringView name)
-	{
-		LockGuard _(m_lock);
-		Thread::TerminateBlocker blocker(Thread::current());
-		if (!mode().ifdir())
-			return BAN::Error::from_errno(ENOTDIR);
-		return delete_inode_impl(name);
-	}
-
 	BAN::ErrorOr<BAN::String> Inode::link_target()
 	{
 		LockGuard _(m_lock);

kernel/kernel/FS/ProcFS/FileSystem.cpp

@@ -1,46 +0,0 @@
-#include <kernel/FS/ProcFS/FileSystem.h>
-#include <kernel/FS/ProcFS/Inode.h>
-#include <kernel/FS/RamFS/Inode.h>
-#include <kernel/LockGuard.h>
-
-namespace Kernel
-{
-
-	static ProcFileSystem* s_instance = nullptr;
-
-	void ProcFileSystem::initialize()
-	{
-		ASSERT(s_instance == nullptr);
-		s_instance = new ProcFileSystem(1024 * 1024);
-		ASSERT(s_instance);
-
-		s_instance->m_root_inode = MUST(RamDirectoryInode::create(*s_instance, 0, 0555, 0, 0));
-		MUST(s_instance->set_root_inode(s_instance->m_root_inode));
-	}
-
-	ProcFileSystem& ProcFileSystem::get()
-	{
-		ASSERT(s_instance);
-		return *s_instance;
-	}
-
-	ProcFileSystem::ProcFileSystem(size_t size)
-		: RamFileSystem(size)
-	{
-	}
-
-	BAN::ErrorOr<void> ProcFileSystem::on_process_create(Process& process)
-	{
-		auto path = BAN::String::formatted("{}", process.pid());
-		auto inode = TRY(ProcPidInode::create(process, *this, 0555, 0, 0));
-		TRY(m_root_inode->add_inode(path, inode));
-		return {};
-	}
-
-	void ProcFileSystem::on_process_delete(Process& process)
-	{
-		auto path = BAN::String::formatted("{}", process.pid());
-		MUST(m_root_inode->delete_inode(path));
-	}
-
-}

kernel/kernel/FS/ProcFS/Inode.cpp

@@ -1,58 +0,0 @@
-#include <kernel/FS/ProcFS/Inode.h>
-
-namespace Kernel
-{
-
-	BAN::ErrorOr<BAN::RefPtr<ProcPidInode>> ProcPidInode::create(Process& process, RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
-	{
-		FullInodeInfo inode_info(fs, mode, uid, gid);
-
-		auto* inode_ptr = new ProcPidInode(process, fs, inode_info);
-		if (inode_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-		auto inode = BAN::RefPtr<ProcPidInode>::adopt(inode_ptr);
-
-		TRY(inode->add_inode("meminfo"sv, MUST(ProcMemInode::create(process, fs, 0755, 0, 0))));
-
-		return inode;
-	}
-
-	ProcPidInode::ProcPidInode(Process& process, RamFileSystem& fs, const FullInodeInfo& inode_info)
-		: RamDirectoryInode(fs, inode_info, fs.root_inode()->ino())
-		, m_process(process)
-	{
-	}
-
-	BAN::ErrorOr<BAN::RefPtr<ProcMemInode>> ProcMemInode::create(Process& process, RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
-	{
-		FullInodeInfo inode_info(fs, mode, uid, gid);
-
-		auto* inode_ptr = new ProcMemInode(process, fs, inode_info);
-		if (inode_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-		return BAN::RefPtr<ProcMemInode>::adopt(inode_ptr);
-	}
-
-	ProcMemInode::ProcMemInode(Process& process, RamFileSystem& fs, const FullInodeInfo& inode_info)
-		: RamInode(fs, inode_info)
-		, m_process(process)
-	{
-		m_inode_info.mode |= Inode::Mode::IFREG;
-	}
-
-	BAN::ErrorOr<size_t> ProcMemInode::read_impl(off_t offset, void* buffer, size_t buffer_size)
-	{
-		ASSERT(offset >= 0);
-		if ((size_t)offset >= sizeof(proc_meminfo_t))
-			return 0;
-
-		proc_meminfo_t meminfo;
-		m_process.get_meminfo(&meminfo);
-
-		size_t bytes = BAN::Math::min<size_t>(buffer_size, sizeof(meminfo) - offset);
-		memcpy(buffer, &meminfo, bytes);
-		
-		return bytes;
-	}
-
-}

kernel/kernel/FS/RamFS/Inode.cpp

@@ -5,50 +5,42 @@
 namespace Kernel
 {
 
-	RamInode::FullInodeInfo::FullInodeInfo(RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
-	{
-		timespec current_time = SystemTimer::get().real_time();
-
-		this->ino = fs.next_ino();
-		this->mode = mode;
-		this->nlink = 1;
-		this->uid = uid;
-		this->gid = gid;
-		this->size = 0;
-		this->atime = current_time;
-		this->mtime = current_time;
-		this->ctime = current_time;
-		this->blksize = fs.blksize();
-		this->blocks = 0;
-
-		// TODO
-		this->dev = 0;
-		this->rdev = 0;
-	}
-
 	/*
 
-		RAM FILE INODE
+		RAM INODE
 
 	*/
 
-	BAN::ErrorOr<BAN::RefPtr<RamFileInode>> RamFileInode::create(RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
+	BAN::ErrorOr<BAN::RefPtr<RamInode>> RamInode::create(RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
 	{
-		FullInodeInfo inode_info(fs, mode, uid, gid);
+		ASSERT(Mode(mode).ifreg());
-
+		auto* ram_inode = new RamInode(fs, mode, uid, gid);
-		auto* ram_inode = new RamFileInode(fs, inode_info);
 		if (ram_inode == nullptr)
 			return BAN::Error::from_errno(ENOMEM);
-		return BAN::RefPtr<RamFileInode>::adopt(ram_inode);
+		return BAN::RefPtr<RamInode>::adopt(ram_inode);
 	}
 
-	RamFileInode::RamFileInode(RamFileSystem& fs, const FullInodeInfo& inode_info)
+	RamInode::RamInode(RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
-		: RamInode(fs, inode_info)
+			: m_fs(fs)
 	{
-		m_inode_info.mode |= Inode::Mode::IFREG;
+		timespec current_time = SystemTimer::get().real_time();
+
+		m_inode_info.ino = fs.next_ino();
+		m_inode_info.mode = mode;
+		m_inode_info.nlink = 1;
+		m_inode_info.uid = uid;
+		m_inode_info.gid = gid;
+		m_inode_info.size = 0;
+		m_inode_info.atime = current_time;
+		m_inode_info.mtime = current_time;
+		m_inode_info.ctime = current_time;
+		m_inode_info.blksize = fs.blksize();
+		m_inode_info.blocks = 0;
+		m_inode_info.dev = 0;
+		m_inode_info.rdev = 0;
 	}
 
-	BAN::ErrorOr<size_t> RamFileInode::read_impl(off_t offset, void* buffer, size_t bytes)
+	BAN::ErrorOr<size_t> RamInode::read_impl(off_t offset, void* buffer, size_t bytes)
 	{
 		ASSERT(offset >= 0);
 		if (offset >= size())
@@ -58,7 +50,7 @@ namespace Kernel
 		return to_copy;
 	}
 
-	BAN::ErrorOr<size_t> RamFileInode::write_impl(off_t offset, const void* buffer, size_t bytes)
+	BAN::ErrorOr<size_t> RamInode::write_impl(off_t offset, const void* buffer, size_t bytes)
 	{
 		ASSERT(offset >= 0);
 		if (offset + bytes > (size_t)size())
@@ -67,7 +59,7 @@ namespace Kernel
 		return bytes;
 	}
 
-	BAN::ErrorOr<void> RamFileInode::truncate_impl(size_t new_size)
+	BAN::ErrorOr<void> RamInode::truncate_impl(size_t new_size)
 	{
 		TRY(m_data.resize(new_size, 0));
 		m_inode_info.size   = m_data.size();
@@ -83,31 +75,30 @@ namespace Kernel
 
 	BAN::ErrorOr<BAN::RefPtr<RamDirectoryInode>> RamDirectoryInode::create(RamFileSystem& fs, ino_t parent, mode_t mode, uid_t uid, gid_t gid)
 	{
-		FullInodeInfo inode_info(fs, mode, uid, gid);
+		ASSERT(Mode(mode).ifdir());
-
+		auto* ram_inode = new RamDirectoryInode(fs, parent, mode, uid, gid);
-		// "." links to this
-		inode_info.nlink++;
-
-		// ".." links to this or parent
-		if (parent)
-			TRY(fs.get_inode(parent))->add_link();
-		else
-		{
-			inode_info.nlink++;
-			parent = inode_info.ino;
-		}
-
-		auto* ram_inode = new RamDirectoryInode(fs, inode_info, parent);
 		if (ram_inode == nullptr)
 			return BAN::Error::from_errno(ENOMEM);
 		return BAN::RefPtr<RamDirectoryInode>::adopt(ram_inode);
 	}
 
-	RamDirectoryInode::RamDirectoryInode(RamFileSystem& fs, const FullInodeInfo& inode_info, ino_t parent)
+	RamDirectoryInode::RamDirectoryInode(RamFileSystem& fs, ino_t parent, mode_t mode, uid_t uid, gid_t gid)
-		: RamInode(fs, inode_info)
+		: RamInode(fs, mode, uid, gid)
-		, m_parent(parent)
 	{
-		m_inode_info.mode |= Inode::Mode::IFDIR;
+		// "." links to this
+		m_inode_info.nlink++;
+
+		// ".." links to this, if there is no parent
+		if (parent == 0)
+		{
+			m_inode_info.nlink++;
+			m_parent = ino();
+		}
+		else
+		{
+			MUST(fs.get_inode(parent))->add_link();
+			m_parent = parent;
+		}
 	}
 
 	BAN::ErrorOr<BAN::RefPtr<Inode>> RamDirectoryInode::find_inode_impl(BAN::StringView name)
@@ -160,7 +151,6 @@ namespace Kernel
 		// "."
 		{
 			ptr->dirent.d_ino = ino();
-			ptr->dirent.d_type = DT_DIR;
 			ptr->rec_len = sizeof(DirectoryEntry) + 2;
 			strcpy(ptr->dirent.d_name, ".");
 			ptr = ptr->next();
@@ -169,7 +159,6 @@ namespace Kernel
 		// ".."
 		{
 			ptr->dirent.d_ino = m_parent;
-			ptr->dirent.d_type = DT_DIR;
 			ptr->rec_len = sizeof(DirectoryEntry) + 3;
 			strcpy(ptr->dirent.d_name, "..");
 			ptr = ptr->next();
@@ -178,7 +167,6 @@ namespace Kernel
 		for (auto& entry : m_entries)
 		{
 			ptr->dirent.d_ino = entry.ino;
-			ptr->dirent.d_type = entry.type;
 			ptr->rec_len = sizeof(DirectoryEntry) + entry.name_len + 1;
 			strcpy(ptr->dirent.d_name, entry.name);
 			ptr = ptr->next();
@@ -193,7 +181,7 @@ namespace Kernel
 	{
 		BAN::RefPtr<RamInode> inode;
 		if (Mode(mode).ifreg())
-			inode = TRY(RamFileInode::create(m_fs, mode, uid, gid));
+			inode = TRY(RamInode::create(m_fs, mode, uid, gid));
 		else if (Mode(mode).ifdir())
 			inode = TRY(RamDirectoryInode::create(m_fs, ino(), mode, uid, gid));
 		else
@@ -204,25 +192,6 @@ namespace Kernel
 		return {};
 	}
 
-	static uint8_t get_type(Inode::Mode mode)
-	{
-		if (mode.ifreg())
-			return DT_REG;
-		if (mode.ifdir())
-			return DT_DIR;
-		if (mode.ifchr())
-			return DT_CHR;
-		if (mode.ifblk())
-			return DT_BLK;
-		if (mode.ififo())
-			return DT_FIFO;
-		if (mode.ifsock())
-			return DT_SOCK;
-		if (mode.iflnk())
-			return DT_LNK;
-		return DT_UNKNOWN;
-	}
-
 	BAN::ErrorOr<void> RamDirectoryInode::add_inode(BAN::StringView name, BAN::RefPtr<RamInode> inode)
 	{
 		if (name.size() > m_name_max)
@@ -237,7 +206,6 @@ namespace Kernel
 		strcpy(entry.name, name.data());
 		entry.name_len = name.size();
 		entry.ino = inode->ino();
-		entry.type = get_type(inode->mode());
 
 		if (auto ret = m_fs.add_inode(inode); ret.is_error())
 		{
@@ -248,44 +216,26 @@ namespace Kernel
 		return {};
 	}
 
-	BAN::ErrorOr<void> RamDirectoryInode::delete_inode_impl(BAN::StringView name)
-	{
-		for (size_t i = 0; i < m_entries.size(); i++)
-		{
-			if (name == m_entries[i].name)
-			{
-				m_entries.remove(i);
-				return {};
-			}
-		}
-		return BAN::Error::from_errno(ENOENT);
-	}
-
 	/*
 
 		RAM SYMLINK INODE
 
 	*/
 
-	BAN::ErrorOr<BAN::RefPtr<RamSymlinkInode>> RamSymlinkInode::create(RamFileSystem& fs, BAN::StringView target_sv, mode_t mode, uid_t uid, gid_t gid)
+	BAN::ErrorOr<BAN::RefPtr<RamSymlinkInode>> RamSymlinkInode::create(RamFileSystem& fs, BAN::StringView target, mode_t mode, uid_t uid, gid_t gid)
 	{
-		FullInodeInfo inode_info(fs, mode, uid, gid);
+		ASSERT(Mode(mode).iflnk());
-
+		auto* ram_inode = new RamSymlinkInode(fs, mode, uid, gid);
-		BAN::String target_str;
-		TRY(target_str.append(target_sv));
-
-		auto* ram_inode = new RamSymlinkInode(fs, inode_info, BAN::move(target_str));
 		if (ram_inode == nullptr)
 			return BAN::Error::from_errno(ENOMEM);
-		return BAN::RefPtr<RamSymlinkInode>::adopt(ram_inode);
+		auto ref_ptr = BAN::RefPtr<RamSymlinkInode>::adopt(ram_inode);
+		TRY(ref_ptr->set_link_target(target));
+		return ref_ptr;
 	}
 
-	RamSymlinkInode::RamSymlinkInode(RamFileSystem& fs, const FullInodeInfo& inode_info, BAN::String&& target)
+	RamSymlinkInode::RamSymlinkInode(RamFileSystem& fs, mode_t mode, uid_t uid, gid_t gid)
-		: RamInode(fs, inode_info)
+		: RamInode(fs, mode, uid, gid)
-		, m_target(BAN::move(target))
+	{ }
-	{
-		m_inode_info.mode |= Inode::Mode::IFLNK;
-	}
 
 	BAN::ErrorOr<BAN::String> RamSymlinkInode::link_target_impl()
 	{

kernel/kernel/FS/VirtualFileSystem.cpp

@@ -2,7 +2,6 @@
 #include <BAN/StringView.h>
 #include <kernel/FS/DevFS/FileSystem.h>
 #include <kernel/FS/Ext2/FileSystem.h>
-#include <kernel/FS/ProcFS/FileSystem.h>
 #include <kernel/FS/RamFS/FileSystem.h>
 #include <kernel/FS/RamFS/Inode.h>
 #include <kernel/FS/VirtualFileSystem.h>
@@ -27,12 +26,14 @@ namespace Kernel
 		s_instance->m_root_fs = MUST(Ext2FS::create(*(Partition*)partition_inode.ptr()));
 
 		Credentials root_creds { 0, 0, 0, 0 };
-		MUST(s_instance->mount(root_creds, &DevFileSystem::get(), "/dev"sv));
+		MUST(s_instance->mount(root_creds, &DevFileSystem::get(), "/dev"));
 
-		MUST(s_instance->mount(root_creds, &ProcFileSystem::get(), "/proc"sv));
+		mode_t tmpfs_mode = Inode::Mode::IFDIR
-
+			 | Inode::Mode::IRUSR | Inode::Mode::IWUSR | Inode::Mode::IXUSR
-		auto* tmpfs = MUST(RamFileSystem::create(1024 * 1024, 0777, 0, 0));
+			 | Inode::Mode::IRGRP | Inode::Mode::IWGRP | Inode::Mode::IXGRP
-		MUST(s_instance->mount(root_creds, tmpfs, "/tmp"sv));
+			 | Inode::Mode::IROTH | Inode::Mode::IWOTH | Inode::Mode::IXOTH;
+		auto* tmpfs = MUST(RamFileSystem::create(1024 * 1024, tmpfs_mode, 0, 0));
+		MUST(s_instance->mount(root_creds, tmpfs, "/tmp"));
 	}
 
 	VirtualFileSystem& VirtualFileSystem::get()

kernel/kernel/Process.cpp

@@ -2,7 +2,6 @@
 #include <BAN/StringView.h>
 #include <kernel/CriticalScope.h>
 #include <kernel/FS/DevFS/FileSystem.h>
-#include <kernel/FS/ProcFS/FileSystem.h>
 #include <kernel/FS/VirtualFileSystem.h>
 #include <kernel/IDT.h>
 #include <kernel/InterruptController.h>
@@ -82,8 +81,6 @@ namespace Kernel
 		auto* process = new Process(credentials, pid, parent, sid, pgrp);
 		ASSERT(process);
 
-		MUST(ProcFileSystem::get().on_process_create(*process));
-
 		return process;
 	}
 
@@ -197,8 +194,6 @@ namespace Kernel
 				s_processes.remove(i);
 		s_process_lock.unlock();
 
-		ProcFileSystem::get().on_process_delete(*this);
-
 		m_lock.lock();
 		m_exit_status.exited = true;
 		while (m_exit_status.waiting > 0)
@@ -252,21 +247,6 @@ namespace Kernel
 			thread->set_terminating();
 	}
 
-	void Process::get_meminfo(proc_meminfo_t* out) const
-	{
-		LockGuard _(m_lock);
-
-		out->page_size = PAGE_SIZE;
-
-		out->virt_pages = 0;
-		for (auto* thread : m_threads)
-			out->virt_pages += thread->virtual_page_count();
-		for (auto& region : m_mapped_regions)
-			out->virt_pages += region->virtual_page_count();
-		if (m_loadable_elf)
-			out->virt_pages += m_loadable_elf->virtual_page_count();
-	}
-
 	BAN::ErrorOr<long> Process::sys_exit(int status)
 	{
 		exit(status, 0);

kernel/kernel/Terminal/TTY.cpp

@@ -32,7 +32,7 @@ namespace Kernel
 		if (inode_or_error.is_error())
 		{
 			if (inode_or_error.error().get_error_code() == ENOENT)
-				DevFileSystem::get().add_device("tty"sv, MUST(RamSymlinkInode::create(DevFileSystem::get(), s_tty->name(), 0666, 0, 0)));
+				DevFileSystem::get().add_device("tty"sv, MUST(RamSymlinkInode::create(DevFileSystem::get(), s_tty->name(), S_IFLNK | 0666, 0, 0)));
 			else
 				dwarnln("{}", inode_or_error.error());
 			return;

kernel/kernel/kernel.cpp

@@ -2,7 +2,6 @@
 #include <kernel/Arch.h>
 #include <kernel/Debug.h>
 #include <kernel/FS/DevFS/FileSystem.h>
-#include <kernel/FS/ProcFS/FileSystem.h>
 #include <kernel/FS/VirtualFileSystem.h>
 #include <kernel/GDT.h>
 #include <kernel/IDT.h>
@@ -132,9 +131,6 @@ extern "C" void kernel_main()
 	DevFileSystem::initialize();
 	dprintln("devfs initialized");
 
-	ProcFileSystem::initialize();
-	dprintln("procfs initialized");
-
 	if (Serial::has_devices())
 	{
 		Serial::initialize_devices();

libc/include/dirent.h

@@ -13,20 +13,10 @@ __BEGIN_DECLS
 struct __DIR;
 typedef struct __DIR DIR;
 
-#define DT_UNKNOWN	0
-#define DT_REG		1
-#define DT_DIR		2
-#define DT_CHR		3
-#define DT_BLK		4
-#define DT_FIFO		5
-#define DT_SOCK		6
-#define DT_LNK		7
-
 struct dirent
 {
-	ino_t d_ino;			/* File serial number. */
+	ino_t d_ino;	/* File serial number. */
-	unsigned char d_type;	/* File type. One of DT_* definitions. */
+	char d_name[];	/* Filename string of entry. */
-	char d_name[];			/* Filename string of entry. */
 };
 
 int				alphasort(const struct dirent** d1, const struct dirent** d2);

libc/include/sys/banan-os.h

@@ -5,9 +5,6 @@
 
 __BEGIN_DECLS
 
-#define __need_size_t 1
-#include <stddef.h>
-
 #define TTY_CMD_SET		0x01
 #define TTY_CMD_UNSET	0x02
 
@@ -17,12 +14,6 @@ __BEGIN_DECLS
 #define POWEROFF_SHUTDOWN 0
 #define POWEROFF_REBOOT 1
 
-struct proc_meminfo_t
-{
-	size_t page_size;
-	size_t virt_pages;
-};
-
 /*
 fildes:		refers to valid tty device
 command:	one of TTY_CMD_* definitions

libc/string.cpp

@@ -62,18 +62,12 @@ int strcmp(const char* s1, const char* s2)
 	return *u1 - *u2;
 }
 
-char* stpcpy(char* __restrict__ dest, const char* __restrict__ src)
-{
-	size_t i = 0;
-	for (; src[i]; i++)
-		dest[i] = src[i];
-	dest[i] = '\0';
-	return &dest[i];
-}
-
 char* strcpy(char* __restrict__ dest, const char* __restrict__ src)
 {
-	stpcpy(dest, src);
+	size_t i;
+	for (i = 0; src[i]; i++)
+		dest[i] = src[i];
+	dest[i] = '\0';
 	return dest;
 }
 

userspace/CMakeLists.txt

@@ -10,7 +10,6 @@ set(USERSPACE_PROJECTS
 	id
 	init
 	ls
-	meminfo
 	mmap-shared-test
 	poweroff
 	Shell

userspace/Shell/main.cpp

@@ -701,17 +701,11 @@ BAN::String get_prompt()
 			}
 			case 'u':
 			{
-				static char* username = nullptr;
+				auto* passwd = getpwuid(geteuid());
-				if (username == nullptr)
+				if (passwd == nullptr)
-				{
+					break;
-					auto* passwd = getpwuid(geteuid());
+				MUST(prompt.append(passwd->pw_name));
-					if (passwd == nullptr)
+				endpwent();
-						break;
-					username = new char[strlen(passwd->pw_name) + 1];
-					strcpy(username, passwd->pw_name);
-					endpwent();
-				}
-				MUST(prompt.append(username));
 				break;
 			}
 			case 'h':

userspace/meminfo/CMakeLists.txt

@@ -1,17 +0,0 @@
-cmake_minimum_required(VERSION 3.26)
-
-project(meminfo CXX)
-
-set(SOURCES
-	main.cpp
-)
-
-add_executable(meminfo ${SOURCES})
-target_compile_options(meminfo PUBLIC -O2 -g)
-target_link_libraries(meminfo PUBLIC libc)
-
-add_custom_target(meminfo-install
-	COMMAND sudo cp ${CMAKE_CURRENT_BINARY_DIR}/meminfo ${BANAN_BIN}/
-	DEPENDS meminfo
-	USES_TERMINAL
-)

userspace/meminfo/main.cpp

@@ -1,57 +0,0 @@
-#include <ctype.h>
-#include <dirent.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/banan-os.h>
-
-bool is_only_digits(const char* str)
-{
-	while (*str)
-		if (!isdigit(*str++))
-			return false;
-	return true;
-}
-
-int main()
-{
-	DIR* proc = opendir("/proc");
-	if (proc == nullptr)
-	{
-		perror("opendir");
-		return 1;
-	}
-
-	char path_buffer[128] {};
-	while (dirent* proc_ent = readdir(proc))
-	{
-		if (proc_ent->d_type != DT_DIR)
-			continue;
-		if (!is_only_digits(proc_ent->d_name))
-			continue;
-
-		strcpy(path_buffer, proc_ent->d_name);
-		strcat(path_buffer, "/meminfo");
-	
-		int fd = openat(dirfd(proc), path_buffer, O_RDONLY);
-		if (fd == -1)
-		{
-			perror("openat");
-			continue;
-		}
-
-		proc_meminfo_t meminfo;
-		if (read(fd, &meminfo, sizeof(meminfo)) == -1)
-			perror("read");
-		else
-		{
-			printf("process:\n");
-			printf("  pid:  %s\n", proc_ent->d_name);
-			printf("  vmem: %zu pages (%zu bytes)\n", meminfo.virt_pages, meminfo.page_size * meminfo.virt_pages);
-		}
-
-		close(fd);
-	}
-
-	closedir(proc);
-}