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 @@ class Inode : public RefCounted<Inode>
 
  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 @@ class Inode : public RefCounted<Inode>
 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,14 +101,14 @@ OBJS = \
  TTY/VirtualConsole.o \
  Thread.o \
  VM/AnonymousVMObject.o \
- VM/InodeVMObject.o \
  VM/MemoryManager.o \
  VM/PageDirectory.o \
  VM/PhysicalPage.o \
  VM/PhysicalRegion.o \
  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 @@ class InodeVMObject final : public VMObject {
  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; }