Kernel: Rename InodeVMObject => SharedInodeVMObject

Kernel/FileSystem/Inode.cpp

@@ -29,7 +29,7 @@
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/FileSystem/InodeWatcher.h>
 #include <Kernel/Net/LocalSocket.h>
-#include <Kernel/VM/InodeVMObject.h>
+#include <Kernel/VM/SharedInodeVMObject.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/FileSystem/Custody.h>
 
@@ -128,14 +128,14 @@ void Inode::will_be_destroyed()
 
 void Inode::inode_contents_changed(off_t offset, ssize_t size, const u8* data)
 {
-    if (m_vmobject)
-        m_vmobject->inode_contents_changed({}, offset, size, data);
+    if (m_shared_vmobject)
+        m_shared_vmobject->inode_contents_changed({}, offset, size, data);
 }
 
 void Inode::inode_size_changed(size_t old_size, size_t new_size)
 {
-    if (m_vmobject)
-        m_vmobject->inode_size_changed({}, old_size, new_size);
+    if (m_shared_vmobject)
+        m_shared_vmobject->inode_size_changed({}, old_size, new_size);
 }
 
 int Inode::set_atime(time_t)
@@ -163,9 +163,9 @@ KResult Inode::decrement_link_count()
     return KResult(-ENOTIMPL);
 }
 
-void Inode::set_vmobject(VMObject& vmobject)
+void Inode::set_shared_vmobject(SharedInodeVMObject& vmobject)
 {
-    m_vmobject = vmobject.make_weak_ptr();
+    m_shared_vmobject = vmobject.make_weak_ptr();
 }
 
 bool Inode::bind_socket(LocalSocket& socket)

Kernel/FileSystem/Inode.h

@@ -99,9 +99,9 @@ public:
 
     void will_be_destroyed();
 
-    void set_vmobject(VMObject&);
-    InodeVMObject* vmobject() { return m_vmobject.ptr(); }
-    const InodeVMObject* vmobject() const { return m_vmobject.ptr(); }
+    void set_shared_vmobject(SharedInodeVMObject&);
+    SharedInodeVMObject* shared_vmobject() { return m_shared_vmobject.ptr(); }
+    const SharedInodeVMObject* shared_vmobject() const { return m_shared_vmobject.ptr(); }
 
     static void sync();
 
@@ -125,7 +125,7 @@ protected:
 private:
     FS& m_fs;
     unsigned m_index { 0 };
-    WeakPtr<InodeVMObject> m_vmobject;
+    WeakPtr<SharedInodeVMObject> m_shared_vmobject;
     RefPtr<LocalSocket> m_socket;
     HashTable<InodeWatcher*> m_watchers;
     bool m_metadata_dirty { false };

Kernel/Forward.h

@@ -39,7 +39,7 @@ class FileDescription;
 class IPv4Socket;
 class Inode;
 class InodeIdentifier;
-class InodeVMObject;
+class SharedInodeVMObject;
 class InodeWatcher;
 class KBuffer;
 class KResult;

Kernel/Makefile

@@ -101,7 +101,6 @@ OBJS = \
     TTY/VirtualConsole.o \
     Thread.o \
     VM/AnonymousVMObject.o \
-    VM/InodeVMObject.o \
     VM/MemoryManager.o \
     VM/PageDirectory.o \
     VM/PhysicalPage.o \
@@ -109,6 +108,7 @@ OBJS = \
     VM/PurgeableVMObject.o \
     VM/RangeAllocator.o \
     VM/Region.o \
+    VM/SharedInodeVMObject.o \
     VM/VMObject.o \
     ACPI/ACPIParser.o \
     ACPI/ACPIStaticParser.o \

Kernel/Process.cpp

@@ -66,7 +66,7 @@
 #include <Kernel/TTY/MasterPTY.h>
 #include <Kernel/TTY/TTY.h>
 #include <Kernel/Thread.h>
-#include <Kernel/VM/InodeVMObject.h>
+#include <Kernel/VM/SharedInodeVMObject.h>
 #include <Kernel/VM/PageDirectory.h>
 #include <Kernel/VM/PurgeableVMObject.h>
 #include <LibBareMetal/IO.h>
@@ -340,10 +340,10 @@ static bool validate_inode_mmap_prot(const Process& process, int prot, const Ino
     if ((prot & PROT_READ) && !metadata.may_read(process))
         return false;
     InterruptDisabler disabler;
-    if (inode.vmobject()) {
-        if ((prot & PROT_EXEC) && inode.vmobject()->writable_mappings())
+    if (inode.shared_vmobject()) {
+        if ((prot & PROT_EXEC) && inode.shared_vmobject()->writable_mappings())
             return false;
-        if ((prot & PROT_WRITE) && inode.vmobject()->executable_mappings())
+        if ((prot & PROT_WRITE) && inode.shared_vmobject()->executable_mappings())
             return false;
     }
     return true;
@@ -548,7 +548,7 @@ int Process::sys$mprotect(void* addr, size_t size, int prot)
         if (whole_region->access() == prot_to_region_access_flags(prot))
             return 0;
         if (whole_region->vmobject().is_inode()
-            && !validate_inode_mmap_prot(*this, prot, static_cast<const InodeVMObject&>(whole_region->vmobject()).inode())) {
+            && !validate_inode_mmap_prot(*this, prot, static_cast<const SharedInodeVMObject&>(whole_region->vmobject()).inode())) {
             return -EACCES;
         }
         whole_region->set_readable(prot & PROT_READ);
@@ -567,7 +567,7 @@ int Process::sys$mprotect(void* addr, size_t size, int prot)
         if (old_region->access() == prot_to_region_access_flags(prot))
             return 0;
         if (old_region->vmobject().is_inode()
-            && !validate_inode_mmap_prot(*this, prot, static_cast<const InodeVMObject&>(old_region->vmobject()).inode())) {
+            && !validate_inode_mmap_prot(*this, prot, static_cast<const SharedInodeVMObject&>(old_region->vmobject()).inode())) {
             return -EACCES;
         }
 
@@ -663,12 +663,12 @@ int Process::sys$purge(int mode)
         }
     }
     if (mode & PURGE_ALL_CLEAN_INODE) {
-        NonnullRefPtrVector<InodeVMObject> vmobjects;
+        NonnullRefPtrVector<SharedInodeVMObject> vmobjects;
         {
             InterruptDisabler disabler;
             MM.for_each_vmobject([&](auto& vmobject) {
                 if (vmobject.is_inode())
-                    vmobjects.append(static_cast<InodeVMObject&>(vmobject));
+                    vmobjects.append(static_cast<SharedInodeVMObject&>(vmobject));
                 return IterationDecision::Continue;
             });
         }
@@ -816,14 +816,14 @@ int Process::do_exec(NonnullRefPtr<FileDescription> main_program_description, Ve
     if (parts.is_empty())
         return -ENOENT;
 
-    RefPtr<InodeVMObject> vmobject;
+    RefPtr<SharedInodeVMObject> vmobject;
     if (interpreter_description) {
-        vmobject = InodeVMObject::create_with_inode(*interpreter_description->inode());
+        vmobject = SharedInodeVMObject::create_with_inode(*interpreter_description->inode());
     } else {
-        vmobject = InodeVMObject::create_with_inode(*main_program_description->inode());
+        vmobject = SharedInodeVMObject::create_with_inode(*main_program_description->inode());
     }
 
-    if (static_cast<const InodeVMObject&>(*vmobject).writable_mappings()) {
+    if (static_cast<const SharedInodeVMObject&>(*vmobject).writable_mappings()) {
         dbg() << "Refusing to execute a write-mapped program";
         return -ETXTBSY;
     }
@@ -3107,10 +3107,10 @@ size_t Process::amount_dirty_private() const
 
 size_t Process::amount_clean_inode() const
 {
-    HashTable<const InodeVMObject*> vmobjects;
+    HashTable<const SharedInodeVMObject*> vmobjects;
     for (auto& region : m_regions) {
         if (region.vmobject().is_inode())
-            vmobjects.set(&static_cast<const InodeVMObject&>(region.vmobject()));
+            vmobjects.set(&static_cast<const SharedInodeVMObject&>(region.vmobject()));
     }
     size_t amount = 0;
     for (auto& vmobject : vmobjects)

Kernel/VM/MemoryManager.cpp

@@ -31,7 +31,7 @@
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/Multiboot.h>
 #include <Kernel/VM/AnonymousVMObject.h>
-#include <Kernel/VM/InodeVMObject.h>
+#include <Kernel/VM/SharedInodeVMObject.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <Kernel/VM/PageDirectory.h>
 #include <Kernel/VM/PhysicalRegion.h>

Kernel/VM/Region.cpp

@@ -28,7 +28,7 @@
 #include <Kernel/Process.h>
 #include <Kernel/Thread.h>
 #include <Kernel/VM/AnonymousVMObject.h>
-#include <Kernel/VM/InodeVMObject.h>
+#include <Kernel/VM/SharedInodeVMObject.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <Kernel/VM/PageDirectory.h>
 #include <Kernel/VM/Region.h>
@@ -50,7 +50,7 @@ Region::Region(const Range& range, const String& name, u8 access, bool cacheable
 
 Region::Region(const Range& range, NonnullRefPtr<Inode> inode, const String& name, u8 access, bool cacheable)
     : m_range(range)
-    , m_vmobject(InodeVMObject::create_with_inode(*inode))
+    , m_vmobject(SharedInodeVMObject::create_with_inode(*inode))
     , m_name(name)
     , m_access(access)
     , m_cacheable(cacheable)
@@ -86,7 +86,7 @@ NonnullOwnPtr<Region> Region::clone()
 {
     ASSERT(Process::current);
 
-    // FIXME: What should we do for privately mapped InodeVMObjects?
+    // FIXME: What should we do for privately mapped SharedInodeVMObjects?
     if (m_shared || vmobject().is_inode()) {
         ASSERT(!m_stack);
 #ifdef MM_DEBUG
@@ -167,7 +167,7 @@ size_t Region::amount_dirty() const
 {
     if (!vmobject().is_inode())
         return amount_resident();
-    return static_cast<const InodeVMObject&>(vmobject()).amount_dirty();
+    return static_cast<const SharedInodeVMObject&>(vmobject()).amount_dirty();
 }
 
 size_t Region::amount_resident() const
@@ -452,7 +452,7 @@ PageFaultResponse Region::handle_inode_fault(size_t page_index_in_region)
     LOCKER(vmobject().m_paging_lock);
     cli();
 
-    auto& inode_vmobject = static_cast<InodeVMObject&>(vmobject());
+    auto& inode_vmobject = static_cast<SharedInodeVMObject&>(vmobject());
     auto& vmobject_physical_page_entry = inode_vmobject.physical_pages()[first_page_index() + page_index_in_region];
 
 #ifdef PAGE_FAULT_DEBUG

Kernel/VM/InodeVMObject.cpp → Kernel/VM/SharedInodeVMObject.cpp

@@ -25,46 +25,46 @@
  */
 
 #include <Kernel/FileSystem/Inode.h>
-#include <Kernel/VM/InodeVMObject.h>
+#include <Kernel/VM/SharedInodeVMObject.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <Kernel/VM/Region.h>
 
 namespace Kernel {
 
-NonnullRefPtr<InodeVMObject> InodeVMObject::create_with_inode(Inode& inode)
+NonnullRefPtr<SharedInodeVMObject> SharedInodeVMObject::create_with_inode(Inode& inode)
 {
     size_t size = inode.size();
-    if (inode.vmobject())
-        return *inode.vmobject();
-    auto vmobject = adopt(*new InodeVMObject(inode, size));
-    vmobject->inode().set_vmobject(*vmobject);
+    if (inode.shared_vmobject())
+        return *inode.shared_vmobject();
+    auto vmobject = adopt(*new SharedInodeVMObject(inode, size));
+    vmobject->inode().set_shared_vmobject(*vmobject);
     return vmobject;
 }
 
-NonnullRefPtr<VMObject> InodeVMObject::clone()
+NonnullRefPtr<VMObject> SharedInodeVMObject::clone()
 {
-    return adopt(*new InodeVMObject(*this));
+    return adopt(*new SharedInodeVMObject(*this));
 }
 
-InodeVMObject::InodeVMObject(Inode& inode, size_t size)
+SharedInodeVMObject::SharedInodeVMObject(Inode& inode, size_t size)
     : VMObject(size)
     , m_inode(inode)
     , m_dirty_pages(page_count(), false)
 {
 }
 
-InodeVMObject::InodeVMObject(const InodeVMObject& other)
+SharedInodeVMObject::SharedInodeVMObject(const SharedInodeVMObject& other)
     : VMObject(other)
     , m_inode(other.m_inode)
 {
 }
 
-InodeVMObject::~InodeVMObject()
+SharedInodeVMObject::~SharedInodeVMObject()
 {
-    ASSERT(inode().vmobject() == this);
+    ASSERT(inode().shared_vmobject() == this);
 }
 
-size_t InodeVMObject::amount_clean() const
+size_t SharedInodeVMObject::amount_clean() const
 {
     size_t count = 0;
     ASSERT(page_count() == (size_t)m_dirty_pages.size());
@@ -75,7 +75,7 @@ size_t InodeVMObject::amount_clean() const
     return count * PAGE_SIZE;
 }
 
-size_t InodeVMObject::amount_dirty() const
+size_t SharedInodeVMObject::amount_dirty() const
 {
     size_t count = 0;
     for (size_t i = 0; i < m_dirty_pages.size(); ++i) {
@@ -85,7 +85,7 @@ size_t InodeVMObject::amount_dirty() const
     return count * PAGE_SIZE;
 }
 
-void InodeVMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size)
+void SharedInodeVMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size)
 {
     dbg() << "VMObject::inode_size_changed: {" << m_inode->fsid() << ":" << m_inode->index() << "} " << old_size << " -> " << new_size;
 
@@ -102,7 +102,7 @@ void InodeVMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new
     });
 }
 
-void InodeVMObject::inode_contents_changed(Badge<Inode>, off_t offset, ssize_t size, const u8* data)
+void SharedInodeVMObject::inode_contents_changed(Badge<Inode>, off_t offset, ssize_t size, const u8* data)
 {
     (void)size;
     (void)data;
@@ -153,13 +153,13 @@ void InodeVMObject::inode_contents_changed(Badge<Inode>, off_t offset, ssize_t s
     });
 }
 
-int InodeVMObject::release_all_clean_pages()
+int SharedInodeVMObject::release_all_clean_pages()
 {
     LOCKER(m_paging_lock);
     return release_all_clean_pages_impl();
 }
 
-int InodeVMObject::release_all_clean_pages_impl()
+int SharedInodeVMObject::release_all_clean_pages_impl()
 {
     int count = 0;
     InterruptDisabler disabler;
@@ -175,20 +175,20 @@ int InodeVMObject::release_all_clean_pages_impl()
     return count;
 }
 
-u32 InodeVMObject::writable_mappings() const
+u32 SharedInodeVMObject::writable_mappings() const
 {
     u32 count = 0;
-    const_cast<InodeVMObject&>(*this).for_each_region([&](auto& region) {
+    const_cast<SharedInodeVMObject&>(*this).for_each_region([&](auto& region) {
         if (region.is_writable())
             ++count;
     });
     return count;
 }
 
-u32 InodeVMObject::executable_mappings() const
+u32 SharedInodeVMObject::executable_mappings() const
 {
     u32 count = 0;
-    const_cast<InodeVMObject&>(*this).for_each_region([&](auto& region) {
+    const_cast<SharedInodeVMObject&>(*this).for_each_region([&](auto& region) {
         if (region.is_executable())
             ++count;
     });

Kernel/VM/InodeVMObject.h → Kernel/VM/SharedInodeVMObject.h

@@ -32,11 +32,11 @@
 
 namespace Kernel {
 
-class InodeVMObject final : public VMObject {
+class SharedInodeVMObject final : public VMObject {
 public:
-    virtual ~InodeVMObject() override;
+    virtual ~SharedInodeVMObject() override;
 
-    static NonnullRefPtr<InodeVMObject> create_with_inode(Inode&);
+    static NonnullRefPtr<SharedInodeVMObject> create_with_inode(Inode&);
     virtual NonnullRefPtr<VMObject> clone() override;
 
     Inode& inode() { return *m_inode; }
@@ -54,12 +54,12 @@ public:
     u32 executable_mappings() const;
 
 private:
-    explicit InodeVMObject(Inode&, size_t);
-    explicit InodeVMObject(const InodeVMObject&);
+    explicit SharedInodeVMObject(Inode&, size_t);
+    explicit SharedInodeVMObject(const SharedInodeVMObject&);
 
-    InodeVMObject& operator=(const InodeVMObject&) = delete;
-    InodeVMObject& operator=(InodeVMObject&&) = delete;
-    InodeVMObject(InodeVMObject&&) = delete;
+    SharedInodeVMObject& operator=(const SharedInodeVMObject&) = delete;
+    SharedInodeVMObject& operator=(SharedInodeVMObject&&) = delete;
+    SharedInodeVMObject(SharedInodeVMObject&&) = delete;
 
     virtual bool is_inode() const override { return true; }