From 457a5df7d50daca6bed8dd03bdc391c7f024b469 Mon Sep 17 00:00:00 2001 From: Andreas Kling Date: Thu, 15 Nov 2018 14:43:10 +0100 Subject: [PATCH] Rename: VirtualFileSystem -> VFS VirtualFileSystem::Node -> Vnode --- Kernel/MemoryManager.cpp | 6 +- Kernel/MemoryManager.h | 12 +-- Kernel/ProcFileSystem.cpp | 10 +- Kernel/Process.cpp | 22 ++--- Kernel/Process.h | 8 +- Kernel/init.cpp | 4 +- VirtualFileSystem/CharacterDevice.cpp | 2 +- VirtualFileSystem/FileDescriptor.cpp | 6 +- VirtualFileSystem/FileDescriptor.h | 10 +- VirtualFileSystem/FileSystem.h | 2 +- VirtualFileSystem/VirtualFileSystem.cpp | 78 ++++++++-------- VirtualFileSystem/VirtualFileSystem.h | 116 +++++++++++++----------- VirtualFileSystem/test.cpp | 4 +- 13 files changed, 143 insertions(+), 137 deletions(-) diff --git a/Kernel/MemoryManager.cpp b/Kernel/MemoryManager.cpp index c5ec1dc603..e3416bcb22 100644 --- a/Kernel/MemoryManager.cpp +++ b/Kernel/MemoryManager.cpp @@ -615,7 +615,7 @@ Region::Region(LinearAddress a, size_t s, String&& n, bool r, bool w, bool cow) MM.register_region(*this); } -Region::Region(LinearAddress a, size_t s, RetainPtr&& vnode, String&& n, bool r, bool w) +Region::Region(LinearAddress a, size_t s, RetainPtr&& vnode, String&& n, bool r, bool w) : linearAddress(a) , size(s) , m_vmo(VMObject::create_file_backed(move(vnode), s)) @@ -655,7 +655,7 @@ void PhysicalPage::return_to_freelist() #endif } -RetainPtr VMObject::create_file_backed(RetainPtr&& vnode, size_t size) +RetainPtr VMObject::create_file_backed(RetainPtr&& vnode, size_t size) { InterruptDisabler disabler; if (vnode->vmo()) @@ -696,7 +696,7 @@ VMObject::VMObject(size_t size) m_physical_pages.resize(page_count()); } -VMObject::VMObject(RetainPtr&& vnode, size_t size) +VMObject::VMObject(RetainPtr&& vnode, size_t size) : m_size(size) , m_vnode(move(vnode)) { diff --git a/Kernel/MemoryManager.h b/Kernel/MemoryManager.h index 5db2c8cc2d..a1230253ba 100644 --- a/Kernel/MemoryManager.h +++ b/Kernel/MemoryManager.h @@ -62,15 +62,15 @@ public: class VMObject : public Retainable { public: - static RetainPtr create_file_backed(RetainPtr&&, size_t); + static RetainPtr create_file_backed(RetainPtr&&, size_t); static RetainPtr create_anonymous(size_t); RetainPtr clone(); ~VMObject(); bool is_anonymous() const { return m_anonymous; } - VirtualFileSystem::Node* vnode() { return m_vnode.ptr(); } - const VirtualFileSystem::Node* vnode() const { return m_vnode.ptr(); } + Vnode* vnode() { return m_vnode.ptr(); } + const Vnode* vnode() const { return m_vnode.ptr(); } size_t vnode_offset() const { return m_vnode_offset; } String name() const { return m_name; } @@ -81,14 +81,14 @@ public: Vector>& physical_pages() { return m_physical_pages; } private: - VMObject(RetainPtr&&, size_t); + VMObject(RetainPtr&&, size_t); explicit VMObject(VMObject&); explicit VMObject(size_t); String m_name; bool m_anonymous { false }; Unix::off_t m_vnode_offset { 0 }; size_t m_size { 0 }; - RetainPtr m_vnode; + RetainPtr m_vnode; Vector> m_physical_pages; }; @@ -96,7 +96,7 @@ class Region : public Retainable { public: Region(LinearAddress, size_t, String&&, bool r, bool w, bool cow = false); Region(LinearAddress, size_t, RetainPtr&&, size_t offset_in_vmo, String&&, bool r, bool w, bool cow = false); - Region(LinearAddress, size_t, RetainPtr&&, String&&, bool r, bool w); + Region(LinearAddress, size_t, RetainPtr&&, String&&, bool r, bool w); ~Region(); const VMObject& vmo() const { return *m_vmo; } diff --git a/Kernel/ProcFileSystem.cpp b/Kernel/ProcFileSystem.cpp index 4b0afc4aa7..958817f12c 100644 --- a/Kernel/ProcFileSystem.cpp +++ b/Kernel/ProcFileSystem.cpp @@ -136,7 +136,7 @@ ByteBuffer procfs$pid_exe(Process& process) ProcessInspectionHandle handle(process); auto inode = process.executable_inode(); ASSERT(inode); - return VirtualFileSystem::the().absolute_path(*inode).toByteBuffer(); + return VFS::the().absolute_path(*inode).toByteBuffer(); } ByteBuffer procfs$pid_cwd(Process& process) @@ -144,7 +144,7 @@ ByteBuffer procfs$pid_cwd(Process& process) ProcessInspectionHandle handle(process); auto inode = process.cwd_inode(); ASSERT(inode); - return VirtualFileSystem::the().absolute_path(*inode).toByteBuffer(); + return VFS::the().absolute_path(*inode).toByteBuffer(); } void ProcFileSystem::addProcess(Process& process) @@ -214,9 +214,9 @@ ByteBuffer procfs$regions() ByteBuffer procfs$mounts() { InterruptDisabler disabler; - auto buffer = ByteBuffer::createUninitialized(VirtualFileSystem::the().mountCount() * 80); + auto buffer = ByteBuffer::createUninitialized(VFS::the().mountCount() * 80); char* ptr = (char*)buffer.pointer(); - VirtualFileSystem::the().forEachMount([&ptr] (auto& mount) { + VFS::the().forEachMount([&ptr] (auto& mount) { auto& fs = mount.fileSystem(); ptr += ksprintf(ptr, "%s @ ", fs.className()); if (!mount.host().isValid()) @@ -330,7 +330,7 @@ ByteBuffer procfs$summary() ByteBuffer procfs$vnodes() { - auto& vfs = VirtualFileSystem::the(); + auto& vfs = VFS::the(); auto buffer = ByteBuffer::createUninitialized(vfs.m_maxNodeCount * 256); char* ptr = (char*)buffer.pointer(); for (size_t i = 0; i < vfs.m_maxNodeCount; ++i) { diff --git a/Kernel/Process.cpp b/Kernel/Process.cpp index 308ea9382d..6ec78994f3 100644 --- a/Kernel/Process.cpp +++ b/Kernel/Process.cpp @@ -102,7 +102,7 @@ Region* Process::allocate_region(LinearAddress laddr, size_t size, String&& name return m_regions.last().ptr(); } -Region* Process::allocate_file_backed_region(LinearAddress laddr, size_t size, RetainPtr&& vnode, String&& name, bool is_readable, bool is_writable) +Region* Process::allocate_file_backed_region(LinearAddress laddr, size_t size, RetainPtr&& vnode, String&& name, bool is_readable, bool is_writable) { ASSERT(!vnode->isCharacterDevice()); @@ -301,7 +301,7 @@ int Process::do_exec(const String& path, Vector&& arguments, Vectorinode : InodeIdentifier()); + auto descriptor = VFS::the().open(path, error, 0, m_cwd ? m_cwd->inode : InodeIdentifier()); if (!descriptor) { ASSERT(error != 0); return error; @@ -483,14 +483,14 @@ Process* Process::create_user_process(const String& path, uid_t uid, gid_t gid, if (arguments.isEmpty()) { arguments.append(parts.last()); } - RetainPtr cwd; + RetainPtr cwd; { InterruptDisabler disabler; if (auto* parent = Process::from_pid(parent_pid)) cwd = parent->m_cwd.copyRef(); } if (!cwd) - cwd = VirtualFileSystem::the().root(); + cwd = VFS::the().root(); auto* process = new Process(parts.takeLast(), uid, gid, parent_pid, Ring3, move(cwd), nullptr, tty); @@ -570,7 +570,7 @@ Process* Process::create_kernel_process(void (*e)(), String&& name) return process; } -Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring, RetainPtr&& cwd, RetainPtr&& executable, TTY* tty, Process* fork_parent) +Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring, RetainPtr&& cwd, RetainPtr&& executable, TTY* tty, Process* fork_parent) : m_name(move(name)) , m_pid(next_pid++) // FIXME: RACE: This variable looks racy! , m_uid(uid) @@ -1124,7 +1124,7 @@ int Process::sys$lstat(const char* path, Unix::stat* statbuf) { VALIDATE_USER_WRITE(statbuf, sizeof(Unix::stat)); int error; - auto descriptor = VirtualFileSystem::the().open(move(path), error, O_NOFOLLOW_NOERROR, cwd_inode()->identifier()); + auto descriptor = VFS::the().open(move(path), error, O_NOFOLLOW_NOERROR, cwd_inode()->identifier()); if (!descriptor) return error; descriptor->stat(statbuf); @@ -1135,7 +1135,7 @@ int Process::sys$stat(const char* path, Unix::stat* statbuf) { VALIDATE_USER_WRITE(statbuf, sizeof(Unix::stat)); int error; - auto descriptor = VirtualFileSystem::the().open(move(path), error, 0, cwd_inode()->identifier()); + auto descriptor = VFS::the().open(move(path), error, 0, cwd_inode()->identifier()); if (!descriptor) return error; descriptor->stat(statbuf); @@ -1148,7 +1148,7 @@ int Process::sys$readlink(const char* path, char* buffer, size_t size) VALIDATE_USER_WRITE(buffer, size); int error; - auto descriptor = VirtualFileSystem::the().open(path, error, O_RDONLY | O_NOFOLLOW_NOERROR, cwd_inode()->identifier()); + auto descriptor = VFS::the().open(path, error, O_RDONLY | O_NOFOLLOW_NOERROR, cwd_inode()->identifier()); if (!descriptor) return error; @@ -1169,7 +1169,7 @@ int Process::sys$chdir(const char* path) { VALIDATE_USER_READ(path, strlen(path)); int error; - auto descriptor = VirtualFileSystem::the().open(path, error, 0, cwd_inode()->identifier()); + auto descriptor = VFS::the().open(path, error, 0, cwd_inode()->identifier()); if (!descriptor) return error; if (!descriptor->isDirectory()) @@ -1182,7 +1182,7 @@ int Process::sys$getcwd(char* buffer, size_t size) { VALIDATE_USER_WRITE(buffer, size); ASSERT(cwd_inode()); - auto path = VirtualFileSystem::the().absolute_path(*cwd_inode()); + auto path = VFS::the().absolute_path(*cwd_inode()); if (path.isNull()) return -EINVAL; if (size < path.length() + 1) @@ -1210,7 +1210,7 @@ int Process::sys$open(const char* path, int options) if (number_of_open_file_descriptors() >= m_max_open_file_descriptors) return -EMFILE; int error; - auto descriptor = VirtualFileSystem::the().open(path, error, options, cwd_inode()->identifier()); + auto descriptor = VFS::the().open(path, error, options, cwd_inode()->identifier()); if (!descriptor) return error; if (options & O_DIRECTORY && !descriptor->isDirectory()) diff --git a/Kernel/Process.h b/Kernel/Process.h index 6a6586dee0..a354d00285 100644 --- a/Kernel/Process.h +++ b/Kernel/Process.h @@ -222,7 +222,7 @@ private: friend class Scheduler; friend class Region; - Process(String&& name, uid_t, gid_t, pid_t ppid, RingLevel, RetainPtr&& cwd = nullptr, RetainPtr&& executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr); + Process(String&& name, uid_t, gid_t, pid_t ppid, RingLevel, RetainPtr&& cwd = nullptr, RetainPtr&& executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr); int do_exec(const String& path, Vector&& arguments, Vector&& environment); void push_value_on_stack(dword); @@ -276,13 +276,13 @@ private: byte m_termination_status { 0 }; byte m_termination_signal { 0 }; - RetainPtr m_cwd; - RetainPtr m_executable; + RetainPtr m_cwd; + RetainPtr m_executable; TTY* m_tty { nullptr }; Region* allocate_region(LinearAddress, size_t, String&& name, bool is_readable = true, bool is_writable = true); - Region* allocate_file_backed_region(LinearAddress, size_t, RetainPtr&& vnode, String&& name, bool is_readable, bool is_writable); + Region* allocate_file_backed_region(LinearAddress, size_t, RetainPtr&& vnode, String&& name, bool is_readable, bool is_writable); Region* allocate_region_with_vmo(LinearAddress, size_t, RetainPtr&&, size_t offset_in_vmo, String&& name, bool is_readable, bool is_writable); bool deallocate_region(Region& region); diff --git a/Kernel/init.cpp b/Kernel/init.cpp index ec20074560..0be397bba5 100644 --- a/Kernel/init.cpp +++ b/Kernel/init.cpp @@ -173,7 +173,7 @@ static void init_stage2() { Syscall::initialize(); - auto vfs = make(); + auto vfs = make(); auto dev_zero = make(); vfs->registerCharacterDevice(*dev_zero); @@ -267,7 +267,7 @@ void init() MemoryManager::initialize(); - VirtualFileSystem::initializeGlobals(); + VFS::initializeGlobals(); StringImpl::initializeGlobals(); PIT::initialize(); diff --git a/VirtualFileSystem/CharacterDevice.cpp b/VirtualFileSystem/CharacterDevice.cpp index c4d70d86db..10afe42b1c 100644 --- a/VirtualFileSystem/CharacterDevice.cpp +++ b/VirtualFileSystem/CharacterDevice.cpp @@ -6,5 +6,5 @@ CharacterDevice::~CharacterDevice() RetainPtr CharacterDevice::open(int options) { - return VirtualFileSystem::the().open(*this, options); + return VFS::the().open(*this, options); } diff --git a/VirtualFileSystem/FileDescriptor.cpp b/VirtualFileSystem/FileDescriptor.cpp index db5fd24fa1..70bb7ea106 100644 --- a/VirtualFileSystem/FileDescriptor.cpp +++ b/VirtualFileSystem/FileDescriptor.cpp @@ -10,7 +10,7 @@ #include "TTY.h" #endif -RetainPtr FileDescriptor::create(RetainPtr&& vnode) +RetainPtr FileDescriptor::create(RetainPtr&& vnode) { return adopt(*new FileDescriptor(move(vnode))); } @@ -25,7 +25,7 @@ RetainPtr FileDescriptor::create_pipe_reader(FIFO& fifo) return adopt(*new FileDescriptor(fifo, FIFO::Reader)); } -FileDescriptor::FileDescriptor(RetainPtr&& vnode) +FileDescriptor::FileDescriptor(RetainPtr&& vnode) : m_vnode(move(vnode)) { } @@ -278,7 +278,7 @@ String FileDescriptor::absolute_path() return buf; } ASSERT(m_vnode->core_inode()); - return VirtualFileSystem::the().absolute_path(*m_vnode->core_inode()); + return VFS::the().absolute_path(*m_vnode->core_inode()); } FileDescriptor::FileDescriptor(FIFO& fifo, FIFO::Direction direction) diff --git a/VirtualFileSystem/FileDescriptor.h b/VirtualFileSystem/FileDescriptor.h index ff81801051..eeb2bec9ca 100644 --- a/VirtualFileSystem/FileDescriptor.h +++ b/VirtualFileSystem/FileDescriptor.h @@ -13,7 +13,7 @@ class TTY; class FileDescriptor : public Retainable { public: - static RetainPtr create(RetainPtr&&); + static RetainPtr create(RetainPtr&&); static RetainPtr create_pipe_writer(FIFO&); static RetainPtr create_pipe_reader(FIFO&); ~FileDescriptor(); @@ -46,7 +46,7 @@ public: InodeMetadata metadata() const { return m_vnode->metadata(); } - VirtualFileSystem::Node* vnode() { return m_vnode.ptr(); } + Vnode* vnode() { return m_vnode.ptr(); } #ifdef SERENITY bool isBlocking() const { return m_isBlocking; } @@ -62,11 +62,11 @@ public: ByteBuffer& generatorCache() { return m_generatorCache; } private: - friend class VirtualFileSystem; - explicit FileDescriptor(RetainPtr&&); + friend class VFS; + explicit FileDescriptor(RetainPtr&&); FileDescriptor(FIFO&, FIFO::Direction); - RetainPtr m_vnode; + RetainPtr m_vnode; RetainPtr m_inode; Unix::off_t m_currentOffset { 0 }; diff --git a/VirtualFileSystem/FileSystem.h b/VirtualFileSystem/FileSystem.h index d826ca7ef7..50d50b7dac 100644 --- a/VirtualFileSystem/FileSystem.h +++ b/VirtualFileSystem/FileSystem.h @@ -65,7 +65,7 @@ private: }; class CoreInode : public Retainable { - friend class VirtualFileSystem; + friend class VFS; public: virtual ~CoreInode(); diff --git a/VirtualFileSystem/VirtualFileSystem.cpp b/VirtualFileSystem/VirtualFileSystem.cpp index f5572078fd..6b54324b23 100644 --- a/VirtualFileSystem/VirtualFileSystem.cpp +++ b/VirtualFileSystem/VirtualFileSystem.cpp @@ -10,45 +10,45 @@ //#define VFS_DEBUG -static VirtualFileSystem* s_the; +static VFS* s_the; #ifndef SERENITY typedef int InterruptDisabler; #endif -VirtualFileSystem& VirtualFileSystem::the() +VFS& VFS::the() { ASSERT(s_the); return *s_the; } -void VirtualFileSystem::initializeGlobals() +void VFS::initializeGlobals() { s_the = nullptr; FileSystem::initializeGlobals(); } -VirtualFileSystem::VirtualFileSystem() +VFS::VFS() { #ifdef VFS_DEBUG kprintf("VFS: Constructing VFS\n"); #endif s_the = this; m_maxNodeCount = 16; - m_nodes = reinterpret_cast(kmalloc(sizeof(Node) * maxNodeCount())); - memset(m_nodes, 0, sizeof(Node) * maxNodeCount()); + m_nodes = reinterpret_cast(kmalloc(sizeof(Vnode) * maxNodeCount())); + memset(m_nodes, 0, sizeof(Vnode) * maxNodeCount()); for (unsigned i = 0; i < m_maxNodeCount; ++i) m_nodeFreeList.append(&m_nodes[i]); } -VirtualFileSystem::~VirtualFileSystem() +VFS::~VFS() { kprintf("VFS: ~VirtualFileSystem with %u nodes allocated\n", allocatedNodeCount()); // FIXME: m_nodes is never freed. Does it matter though? } -auto VirtualFileSystem::makeNode(InodeIdentifier inode) -> RetainPtr +auto VFS::makeNode(InodeIdentifier inode) -> RetainPtr { auto metadata = inode.metadata(); if (!metadata.isValid()) @@ -91,7 +91,7 @@ auto VirtualFileSystem::makeNode(InodeIdentifier inode) -> RetainPtr return vnode; } -auto VirtualFileSystem::makeNode(CharacterDevice& device) -> RetainPtr +auto VFS::makeNode(CharacterDevice& device) -> RetainPtr { InterruptDisabler disabler; auto vnode = allocateNode(); @@ -107,7 +107,7 @@ auto VirtualFileSystem::makeNode(CharacterDevice& device) -> RetainPtr return vnode; } -auto VirtualFileSystem::getOrCreateNode(InodeIdentifier inode) -> RetainPtr +auto VFS::getOrCreateNode(InodeIdentifier inode) -> RetainPtr { { InterruptDisabler disabler; @@ -118,7 +118,7 @@ auto VirtualFileSystem::getOrCreateNode(InodeIdentifier inode) -> RetainPtr RetainPtr +auto VFS::getOrCreateNode(CharacterDevice& device) -> RetainPtr { { InterruptDisabler disabler; @@ -129,7 +129,7 @@ auto VirtualFileSystem::getOrCreateNode(CharacterDevice& device) -> RetainPtr&& fileSystem, const String& path) +bool VFS::mount(RetainPtr&& fileSystem, const String& path) { ASSERT(fileSystem); int error; @@ -146,7 +146,7 @@ bool VirtualFileSystem::mount(RetainPtr&& fileSystem, const String& return true; } -bool VirtualFileSystem::mountRoot(RetainPtr&& fileSystem) +bool VFS::mountRoot(RetainPtr&& fileSystem) { if (m_rootNode) { kprintf("VFS: mountRoot can't mount another root\n"); @@ -175,7 +175,7 @@ bool VirtualFileSystem::mountRoot(RetainPtr&& fileSystem) return true; } -auto VirtualFileSystem::allocateNode() -> RetainPtr +auto VFS::allocateNode() -> RetainPtr { if (m_nodeFreeList.isEmpty()) { kprintf("VFS: allocateNode has no nodes left\n"); @@ -189,7 +189,7 @@ auto VirtualFileSystem::allocateNode() -> RetainPtr return adopt(*node); } -void VirtualFileSystem::freeNode(Node* node) +void VFS::freeNode(Vnode* node) { InterruptDisabler disabler; ASSERT(node); @@ -209,7 +209,7 @@ void VirtualFileSystem::freeNode(Node* node) } #ifndef SERENITY -bool VirtualFileSystem::isDirectory(const String& path, InodeIdentifier base) +bool VFS::isDirectory(const String& path, InodeIdentifier base) { int error; auto inode = resolvePath(path, error, base); @@ -220,7 +220,7 @@ bool VirtualFileSystem::isDirectory(const String& path, InodeIdentifier base) } #endif -auto VirtualFileSystem::findMountForHost(InodeIdentifier inode) -> Mount* +auto VFS::findMountForHost(InodeIdentifier inode) -> Mount* { for (auto& mount : m_mounts) { if (mount->host() == inode) @@ -229,7 +229,7 @@ auto VirtualFileSystem::findMountForHost(InodeIdentifier inode) -> Mount* return nullptr; } -auto VirtualFileSystem::findMountForGuest(InodeIdentifier inode) -> Mount* +auto VFS::findMountForGuest(InodeIdentifier inode) -> Mount* { for (auto& mount : m_mounts) { if (mount->guest() == inode) @@ -238,12 +238,12 @@ auto VirtualFileSystem::findMountForGuest(InodeIdentifier inode) -> Mount* return nullptr; } -bool VirtualFileSystem::isRoot(InodeIdentifier inode) const +bool VFS::is_vfs_root(InodeIdentifier inode) const { return inode == m_rootNode->inode; } -void VirtualFileSystem::enumerateDirectoryInode(InodeIdentifier directoryInode, Function callback) +void VFS::enumerateDirectoryInode(InodeIdentifier directoryInode, Function callback) { if (!directoryInode.isValid()) return; @@ -255,7 +255,7 @@ void VirtualFileSystem::enumerateDirectoryInode(InodeIdentifier directoryInode, else resolvedInode = entry.inode; - if (directoryInode.isRootInode() && !isRoot(directoryInode) && !strcmp(entry.name, "..")) { + if (directoryInode.isRootInode() && !is_vfs_root(directoryInode) && !strcmp(entry.name, "..")) { auto mount = findMountForGuest(entry.inode); ASSERT(mount); resolvedInode = mount->host(); @@ -266,7 +266,7 @@ void VirtualFileSystem::enumerateDirectoryInode(InodeIdentifier directoryInode, } #ifndef SERENITY -void VirtualFileSystem::listDirectory(const String& path, InodeIdentifier base) +void VFS::listDirectory(const String& path, InodeIdentifier base) { int error; auto directoryInode = resolvePath(path, error, base); @@ -367,7 +367,7 @@ void VirtualFileSystem::listDirectory(const String& path, InodeIdentifier base) }); } -void VirtualFileSystem::listDirectoryRecursively(const String& path, InodeIdentifier base) +void VFS::listDirectoryRecursively(const String& path, InodeIdentifier base) { int error; auto directory = resolvePath(path, error, base); @@ -392,7 +392,7 @@ void VirtualFileSystem::listDirectoryRecursively(const String& path, InodeIdenti } #endif -bool VirtualFileSystem::touch(const String& path) +bool VFS::touch(const String& path) { int error; auto inode = resolvePath(path, error); @@ -401,7 +401,7 @@ bool VirtualFileSystem::touch(const String& path) return inode.fileSystem()->setModificationTime(inode, ktime(nullptr)); } -RetainPtr VirtualFileSystem::open(CharacterDevice& device, int options) +RetainPtr VFS::open(CharacterDevice& device, int options) { // FIXME: Respect options. (void) options; @@ -411,7 +411,7 @@ RetainPtr VirtualFileSystem::open(CharacterDevice& device, int o return FileDescriptor::create(move(vnode)); } -RetainPtr VirtualFileSystem::open(const String& path, int& error, int options, InodeIdentifier base) +RetainPtr VFS::open(const String& path, int& error, int options, InodeIdentifier base) { auto inode = resolvePath(path, error, base, options); if (!inode.isValid()) @@ -422,7 +422,7 @@ RetainPtr VirtualFileSystem::open(const String& path, int& error return FileDescriptor::create(move(vnode)); } -RetainPtr VirtualFileSystem::create(const String& path, InodeIdentifier base) +RetainPtr VFS::create(const String& path, InodeIdentifier base) { // FIXME: Do the real thing, not just this fake thing! (void) path; @@ -431,7 +431,7 @@ RetainPtr VirtualFileSystem::create(const String& path, InodeIde return nullptr; } -RetainPtr VirtualFileSystem::mkdir(const String& path, InodeIdentifier base) +RetainPtr VFS::mkdir(const String& path, InodeIdentifier base) { // FIXME: Do the real thing, not just this fake thing! (void) path; @@ -440,7 +440,7 @@ RetainPtr VirtualFileSystem::mkdir(const String& path, InodeIden return nullptr; } -InodeIdentifier VirtualFileSystem::resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error) +InodeIdentifier VFS::resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error) { auto symlinkContents = symlinkInode.readEntireFile(); if (!symlinkContents) @@ -452,14 +452,14 @@ InodeIdentifier VirtualFileSystem::resolveSymbolicLink(InodeIdentifier base, Ino return resolvePath(linkee, error, base); } -RetainPtr VirtualFileSystem::get_inode(InodeIdentifier inode_id) +RetainPtr VFS::get_inode(InodeIdentifier inode_id) { if (!inode_id.isValid()) return nullptr; return inode_id.fileSystem()->get_inode(inode_id); } -String VirtualFileSystem::absolute_path(CoreInode& core_inode) +String VFS::absolute_path(CoreInode& core_inode) { int error; Vector lineage; @@ -494,7 +494,7 @@ String VirtualFileSystem::absolute_path(CoreInode& core_inode) return builder.build(); } -InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, InodeIdentifier base, int options) +InodeIdentifier VFS::resolvePath(const String& path, int& error, InodeIdentifier base, int options) { if (path.isEmpty()) return { }; @@ -545,7 +545,7 @@ InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, I #endif inode = mount->guest(); } - if (wasRootInodeAtHeadOfLoop && inode.isRootInode() && !isRoot(inode) && part == "..") { + if (wasRootInodeAtHeadOfLoop && inode.isRootInode() && !is_vfs_root(inode) && part == "..") { #ifdef VFS_DEBUG kprintf(" -- is guest\n"); #endif @@ -574,13 +574,13 @@ InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, I return inode; } -void VirtualFileSystem::Node::retain() +void Vnode::retain() { InterruptDisabler disabler; // FIXME: Make a Retainable with atomic retain count instead. ++retainCount; } -void VirtualFileSystem::Node::release() +void Vnode::release() { InterruptDisabler disabler; // FIXME: Make a Retainable with atomic retain count instead. ASSERT(retainCount); @@ -589,7 +589,7 @@ void VirtualFileSystem::Node::release() } } -const InodeMetadata& VirtualFileSystem::Node::metadata() const +const InodeMetadata& Vnode::metadata() const { if (m_core_inode) return m_core_inode->metadata(); @@ -598,19 +598,19 @@ const InodeMetadata& VirtualFileSystem::Node::metadata() const return m_cachedMetadata; } -VirtualFileSystem::Mount::Mount(InodeIdentifier host, RetainPtr&& guestFileSystem) +VFS::Mount::Mount(InodeIdentifier host, RetainPtr&& guestFileSystem) : m_host(host) , m_guest(guestFileSystem->rootInode()) , m_fileSystem(move(guestFileSystem)) { } -void VirtualFileSystem::registerCharacterDevice(CharacterDevice& device) +void VFS::registerCharacterDevice(CharacterDevice& device) { m_characterDevices.set(encodedDevice(device.major(), device.minor()), &device); } -void VirtualFileSystem::forEachMount(Function callback) const +void VFS::forEachMount(Function callback) const { for (auto& mount : m_mounts) { callback(*mount); diff --git a/VirtualFileSystem/VirtualFileSystem.h b/VirtualFileSystem/VirtualFileSystem.h index 286506798b..35c0466a75 100644 --- a/VirtualFileSystem/VirtualFileSystem.h +++ b/VirtualFileSystem/VirtualFileSystem.h @@ -33,7 +33,46 @@ inline constexpr dword encodedDevice(unsigned major, unsigned minor) return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12); } -class VirtualFileSystem { +class VFS; + +class Vnode { +public: + InodeIdentifier inode; + const InodeMetadata& metadata() const; + + bool inUse() const { return inode.isValid() || m_characterDevice; } + + bool isCharacterDevice() const { return m_characterDevice; } + CharacterDevice* characterDevice() { return m_characterDevice; } + const CharacterDevice* characterDevice() const { return m_characterDevice; } + + void retain(); + void release(); + + FileSystem* fileSystem() { return inode.fileSystem(); } + const FileSystem* fileSystem() const { return inode.fileSystem(); } + + VFS* vfs() { return m_vfs; } + const VFS* vfs() const { return m_vfs; } + + void* vmo() { return m_vmo; } + void set_vmo(void* vmo) { m_vmo = vmo; } + + unsigned retain_count() const { return retainCount; } + + CoreInode* core_inode() { return m_core_inode.ptr(); } + +private: + friend class VFS; + VFS* m_vfs { nullptr }; + unsigned retainCount { 0 }; + CharacterDevice* m_characterDevice { nullptr }; + mutable InodeMetadata m_cachedMetadata; + void* m_vmo { nullptr }; + RetainPtr m_core_inode; +}; + +class VFS { AK_MAKE_ETERNAL friend ByteBuffer procfs$vnodes(); public: @@ -54,56 +93,22 @@ public: RetainPtr m_fileSystem; }; - struct Node { - InodeIdentifier inode; - const InodeMetadata& metadata() const; + static VFS& the() PURE; - bool inUse() const { return inode.isValid() || m_characterDevice; } - - bool isCharacterDevice() const { return m_characterDevice; } - CharacterDevice* characterDevice() { return m_characterDevice; } - const CharacterDevice* characterDevice() const { return m_characterDevice; } - - void retain(); - void release(); - - FileSystem* fileSystem() { return inode.fileSystem(); } - const FileSystem* fileSystem() const { return inode.fileSystem(); } - - VirtualFileSystem* vfs() { return m_vfs; } - const VirtualFileSystem* vfs() const { return m_vfs; } - - void* vmo() { return m_vmo; } - void set_vmo(void* vmo) { m_vmo = vmo; } - - unsigned retain_count() const { return retainCount; } - - CoreInode* core_inode() { return m_core_inode.ptr(); } - - private: - friend class VirtualFileSystem; - VirtualFileSystem* m_vfs { nullptr }; - unsigned retainCount { 0 }; - CharacterDevice* m_characterDevice { nullptr }; - mutable InodeMetadata m_cachedMetadata; - void* m_vmo { nullptr }; - RetainPtr m_core_inode; - }; - - static VirtualFileSystem& the() PURE; - - VirtualFileSystem(); - ~VirtualFileSystem(); + VFS(); + ~VFS(); +#ifndef SERENITY bool isDirectory(const String& path, InodeIdentifier base = InodeIdentifier()); void listDirectory(const String& path, InodeIdentifier base); void listDirectoryRecursively(const String& path, InodeIdentifier base); +#endif unsigned maxNodeCount() const { return m_maxNodeCount; } unsigned allocatedNodeCount() const { return m_maxNodeCount - m_nodeFreeList.size(); } - Node* root() { return m_rootNode.ptr(); } - const Node* root() const { return m_rootNode.ptr(); } + Vnode* root() { return m_rootNode.ptr(); } + const Vnode* root() const { return m_rootNode.ptr(); } bool mountRoot(RetainPtr&&); bool mount(RetainPtr&&, const String& path); @@ -113,8 +118,6 @@ public: RetainPtr create(const String& path, InodeIdentifier base = InodeIdentifier()); RetainPtr mkdir(const String& path, InodeIdentifier base = InodeIdentifier()); - bool isRoot(InodeIdentifier) const; - bool touch(const String&path); void registerCharacterDevice(CharacterDevice&); @@ -126,36 +129,39 @@ public: private: friend class FileDescriptor; + friend class Vnode; RetainPtr get_inode(InodeIdentifier); + bool is_vfs_root(InodeIdentifier) const; + void enumerateDirectoryInode(InodeIdentifier, Function); InodeIdentifier resolve_path(const String& path, int& error, CoreInode& base, int options = 0); InodeIdentifier resolvePath(const String& path, int& error, InodeIdentifier base = InodeIdentifier(), int options = 0); InodeIdentifier resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error); - RetainPtr allocateNode(); - void freeNode(Node*); + RetainPtr allocateNode(); + void freeNode(Vnode*); - RetainPtr makeNode(InodeIdentifier); - RetainPtr makeNode(CharacterDevice&); - RetainPtr getOrCreateNode(InodeIdentifier); - RetainPtr getOrCreateNode(CharacterDevice&); + RetainPtr makeNode(InodeIdentifier); + RetainPtr makeNode(CharacterDevice&); + RetainPtr getOrCreateNode(InodeIdentifier); + RetainPtr getOrCreateNode(CharacterDevice&); Mount* findMountForHost(InodeIdentifier); Mount* findMountForGuest(InodeIdentifier); - HashMap m_inode2vnode; - HashMap m_device2vnode; + HashMap m_inode2vnode; + HashMap m_device2vnode; Vector> m_mounts; unsigned m_maxNodeCount { 0 }; - Node* m_nodes { nullptr }; + Vnode* m_nodes { nullptr }; - Vector m_nodeFreeList; + Vector m_nodeFreeList; - RetainPtr m_rootNode; + RetainPtr m_rootNode; HashMap m_characterDevices; }; diff --git a/VirtualFileSystem/test.cpp b/VirtualFileSystem/test.cpp index d39650dd89..7fc1c0ecd7 100644 --- a/VirtualFileSystem/test.cpp +++ b/VirtualFileSystem/test.cpp @@ -22,9 +22,9 @@ int main(int c, char** v) if (c >= 2) filename = v[1]; - VirtualFileSystem::initializeGlobals(); + VFS::initializeGlobals(); - VirtualFileSystem vfs; + VFS vfs; auto zero = make(); vfs.registerCharacterDevice(*zero);