Kernel: Rename FileDescription => OpenFileDescription

Dr. POSIX really calls these "open file description", not just
"file description", so let's call them exactly that. :^)

Kernel/ACPI/Parser.cpp

@@ -31,7 +31,7 @@ UNMAP_AFTER_INIT NonnullRefPtr<ACPISysFSComponent> ACPISysFSComponent::create(St
     return adopt_ref(*new (nothrow) ACPISysFSComponent(name, paddr, table_size));
 }
 
-KResultOr<size_t> ACPISysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> ACPISysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     auto blob = try_to_generate_buffer();
     if (!blob)

Kernel/ACPI/Parser.h

@@ -28,7 +28,7 @@ class ACPISysFSComponent : public SysFSComponent {
 public:
     static NonnullRefPtr<ACPISysFSComponent> create(String name, PhysicalAddress, size_t table_size);
 
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
 
 protected:
     OwnPtr<KBuffer> try_to_generate_buffer() const;

Kernel/Arch/PC/BIOS.cpp

@@ -7,7 +7,7 @@
 
 #include <AK/StringView.h>
 #include <Kernel/Arch/PC/BIOS.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/KBufferBuilder.h>
 #include <Kernel/Memory/MemoryManager.h>
 #include <Kernel/Memory/TypedMapping.h>
@@ -29,7 +29,7 @@ UNMAP_AFTER_INIT BIOSSysFSComponent::BIOSSysFSComponent(String name)
 {
 }
 
-KResultOr<size_t> BIOSSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> BIOSSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     auto blob = try_to_generate_buffer();
     if (!blob)

Kernel/Arch/PC/BIOS.h

@@ -60,7 +60,7 @@ Memory::MappedROM map_ebda();
 
 class BIOSSysFSComponent : public SysFSComponent {
 public:
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
 
 protected:
     virtual OwnPtr<KBuffer> try_to_generate_buffer() const = 0;

Kernel/Bus/PCI/SysFSPCI.cpp

@@ -60,7 +60,7 @@ PCIDeviceAttributeSysFSComponent::PCIDeviceAttributeSysFSComponent(String name,
 {
 }
 
-KResultOr<size_t> PCIDeviceAttributeSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> PCIDeviceAttributeSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     auto blob = try_to_generate_buffer();
     if (!blob)

Kernel/Bus/PCI/SysFSPCI.h

@@ -37,7 +37,7 @@ class PCIDeviceAttributeSysFSComponent : public SysFSComponent {
 public:
     static NonnullRefPtr<PCIDeviceAttributeSysFSComponent> create(String name, const PCIDeviceSysFSDirectory& device, size_t offset, size_t field_bytes_width);
 
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
     virtual ~PCIDeviceAttributeSysFSComponent() {};
 
 protected:

Kernel/Bus/USB/SysFSUSB.cpp

@@ -47,7 +47,7 @@ KResult SysFSUSBDeviceInformation::try_generate(KBufferBuilder& builder)
     return KSuccess;
 }
 
-KResult SysFSUSBDeviceInformation::refresh_data(FileDescription& description) const
+KResult SysFSUSBDeviceInformation::refresh_data(OpenFileDescription& description) const
 {
     MutexLocker lock(m_lock);
     auto& cached_data = description.data();
@@ -63,7 +63,7 @@ KResult SysFSUSBDeviceInformation::refresh_data(FileDescription& description) co
     return KSuccess;
 }
 
-KResultOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
+KResultOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     dbgln_if(PROCFS_DEBUG, "SysFSUSBDeviceInformation @ {}: read_bytes offset: {} count: {}", name(), offset, count);
 

Kernel/Bus/USB/SysFSUSB.h

@@ -26,7 +26,7 @@ public:
 protected:
     explicit SysFSUSBDeviceInformation(USB::Device& device);
 
-    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
 
     IntrusiveListNode<SysFSUSBDeviceInformation, RefPtr<SysFSUSBDeviceInformation>> m_list_node;
 
@@ -34,7 +34,7 @@ protected:
 
 private:
     KResult try_generate(KBufferBuilder&);
-    virtual KResult refresh_data(FileDescription& description) const override;
+    virtual KResult refresh_data(OpenFileDescription& description) const override;
     mutable Mutex m_lock { "SysFSUSBDeviceInformation" };
 };
 

Kernel/Bus/VirtIO/ConsolePort.cpp

@@ -86,12 +86,12 @@ void ConsolePort::handle_queue_update(Badge<VirtIO::Console>, u16 queue_index)
     }
 }
 
-bool ConsolePort::can_read(const FileDescription&, size_t) const
+bool ConsolePort::can_read(const OpenFileDescription&, size_t) const
 {
     return m_receive_buffer->used_bytes() > 0;
 }
 
-KResultOr<size_t> ConsolePort::read(FileDescription& desc, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> ConsolePort::read(OpenFileDescription& desc, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (!size)
         return 0;
@@ -119,12 +119,12 @@ KResultOr<size_t> ConsolePort::read(FileDescription& desc, u64, UserOrKernelBuff
     return bytes_copied;
 }
 
-bool ConsolePort::can_write(const FileDescription&, size_t) const
+bool ConsolePort::can_write(const OpenFileDescription&, size_t) const
 {
     return m_console.get_queue(m_transmit_queue).has_free_slots() && m_transmit_buffer->has_space();
 }
 
-KResultOr<size_t> ConsolePort::write(FileDescription& desc, u64, const UserOrKernelBuffer& data, size_t size)
+KResultOr<size_t> ConsolePort::write(OpenFileDescription& desc, u64, const UserOrKernelBuffer& data, size_t size)
 {
     if (!size)
         return 0;
@@ -163,7 +163,7 @@ String ConsolePort::device_name() const
     return String::formatted("hvc{}p{}", m_console.device_id(), m_port);
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> ConsolePort::open(int options)
+KResultOr<NonnullRefPtr<OpenFileDescription>> ConsolePort::open(int options)
 {
     if (!m_open)
         m_console.send_open_control_message(m_port, true);

Kernel/Bus/VirtIO/ConsolePort.h

@@ -9,7 +9,7 @@
 
 #include <Kernel/Bus/VirtIO/Device.h>
 #include <Kernel/Devices/CharacterDevice.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Memory/RingBuffer.h>
 
 namespace Kernel::VirtIO {
@@ -34,11 +34,11 @@ private:
 
     virtual StringView class_name() const override { return "VirtIOConsolePort"; }
 
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<NonnullRefPtr<FileDescription>> open(int options) override;
+    virtual KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
 
     mode_t required_mode() const override { return 0666; }
 

Kernel/CMakeLists.txt

@@ -115,13 +115,13 @@ set(KERNEL_SOURCES
     FileSystem/FIFO.cpp
     FileSystem/File.cpp
     FileSystem/FileBackedFileSystem.cpp
-    FileSystem/FileDescription.cpp
     FileSystem/FileSystem.cpp
     FileSystem/Inode.cpp
     FileSystem/InodeFile.cpp
     FileSystem/InodeWatcher.cpp
     FileSystem/ISO9660FileSystem.cpp
     FileSystem/Mount.cpp
+    FileSystem/OpenFileDescription.cpp
     FileSystem/Plan9FileSystem.cpp
     FileSystem/ProcFS.cpp
     FileSystem/SysFS.cpp
@@ -420,7 +420,7 @@ if (ENABLE_KERNEL_COVERAGE_COLLECTION)
         ../Kernel/Devices/KCOVDevice.cpp
         ../Kernel/Devices/KCOVInstance.cpp
         ../Kernel/FileSystem/File.cpp
-        ../Kernel/FileSystem/FileDescription.cpp
+        ../Kernel/FileSystem/OpenFileDescription.cpp
         ../Kernel/Heap/SlabAllocator.cpp
         ../Kernel/init.cpp
         ../Kernel/SanCov.cpp

Kernel/ConsoleDevice.cpp

@@ -41,19 +41,19 @@ UNMAP_AFTER_INIT ConsoleDevice::~ConsoleDevice()
 {
 }
 
-bool ConsoleDevice::can_read(const Kernel::FileDescription&, size_t) const
+bool ConsoleDevice::can_read(const Kernel::OpenFileDescription&, size_t) const
 {
     return false;
 }
 
-Kernel::KResultOr<size_t> ConsoleDevice::read(FileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t)
+Kernel::KResultOr<size_t> ConsoleDevice::read(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t)
 {
     // FIXME: Implement reading from the console.
     //        Maybe we could use a ring buffer for this device?
     return 0;
 }
 
-Kernel::KResultOr<size_t> ConsoleDevice::write(FileDescription&, u64, const Kernel::UserOrKernelBuffer& data, size_t size)
+Kernel::KResultOr<size_t> ConsoleDevice::write(OpenFileDescription&, u64, const Kernel::UserOrKernelBuffer& data, size_t size)
 {
     if (!size)
         return 0;

Kernel/ConsoleDevice.h

@@ -23,10 +23,10 @@ public:
     virtual ~ConsoleDevice() override;
 
     // ^CharacterDevice
-    virtual bool can_read(const Kernel::FileDescription&, size_t) const override;
+    virtual bool can_read(const Kernel::OpenFileDescription&, size_t) const override;
-    virtual bool can_write(const Kernel::FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const Kernel::OpenFileDescription&, size_t) const override { return true; }
-    virtual Kernel::KResultOr<size_t> read(FileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t) override;
+    virtual Kernel::KResultOr<size_t> read(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t) override;
-    virtual Kernel::KResultOr<size_t> write(FileDescription&, u64, const Kernel::UserOrKernelBuffer&, size_t) override;
+    virtual Kernel::KResultOr<size_t> write(OpenFileDescription&, u64, const Kernel::UserOrKernelBuffer&, size_t) override;
     virtual StringView class_name() const override { return "Console"; }
 
     void put_char(char);

Kernel/Coredump.cpp

@@ -11,7 +11,7 @@
 #include <AK/JsonObjectSerializer.h>
 #include <Kernel/Coredump.h>
 #include <Kernel/FileSystem/Custody.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/KLexicalPath.h>
 #include <Kernel/Locking/Spinlock.h>
@@ -34,14 +34,14 @@ KResultOr<NonnullOwnPtr<Coredump>> Coredump::try_create(NonnullRefPtr<Process> p
     return adopt_nonnull_own_or_enomem(new (nothrow) Coredump(move(process), move(description)));
 }
 
-Coredump::Coredump(NonnullRefPtr<Process> process, NonnullRefPtr<FileDescription> description)
+Coredump::Coredump(NonnullRefPtr<Process> process, NonnullRefPtr<OpenFileDescription> description)
     : m_process(move(process))
     , m_description(move(description))
     , m_num_program_headers(m_process->address_space().region_count() + 1) // +1 for NOTE segment
 {
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> Coredump::try_create_target_file(Process const& process, StringView output_path)
+KResultOr<NonnullRefPtr<OpenFileDescription>> Coredump::try_create_target_file(Process const& process, StringView output_path)
 {
     auto output_directory = KLexicalPath::dirname(output_path);
     auto dump_directory = TRY(VirtualFileSystem::the().open_directory(output_directory, VirtualFileSystem::the().root_custody()));

Kernel/Coredump.h

@@ -21,8 +21,8 @@ public:
     KResult write();
 
 private:
-    Coredump(NonnullRefPtr<Process>, NonnullRefPtr<FileDescription>);
+    Coredump(NonnullRefPtr<Process>, NonnullRefPtr<OpenFileDescription>);
-    static KResultOr<NonnullRefPtr<FileDescription>> try_create_target_file(Process const&, StringView output_path);
+    static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create_target_file(Process const&, StringView output_path);
 
     KResult write_elf_header();
     KResult write_program_headers(size_t notes_size);
@@ -36,7 +36,7 @@ private:
     KResult create_notes_metadata_data(auto&) const;
 
     NonnullRefPtr<Process> m_process;
-    NonnullRefPtr<FileDescription> m_description;
+    NonnullRefPtr<OpenFileDescription> m_description;
     const size_t m_num_program_headers;
 };
 

Kernel/Devices/Device.cpp

@@ -55,7 +55,7 @@ String Device::absolute_path() const
     return String::formatted("/dev/{}", device_name());
 }
 
-String Device::absolute_path(const FileDescription&) const
+String Device::absolute_path(const OpenFileDescription&) const
 {
     return absolute_path();
 }

Kernel/Devices/Device.h

@@ -31,7 +31,7 @@ public:
     unsigned major() const { return m_major; }
     unsigned minor() const { return m_minor; }
 
-    virtual String absolute_path(const FileDescription&) const override;
+    virtual String absolute_path(const OpenFileDescription&) const override;
     virtual String absolute_path() const;
 
     UserID uid() const { return m_uid; }

Kernel/Devices/FullDevice.cpp

@@ -25,18 +25,18 @@ UNMAP_AFTER_INIT FullDevice::~FullDevice()
 {
 }
 
-bool FullDevice::can_read(const FileDescription&, size_t) const
+bool FullDevice::can_read(const OpenFileDescription&, size_t) const
 {
     return true;
 }
 
-KResultOr<size_t> FullDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> FullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     TRY(buffer.memset(0, size));
     return size;
 }
 
-KResultOr<size_t> FullDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t size)
+KResultOr<size_t> FullDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
 {
     if (size == 0)
         return 0;

Kernel/Devices/FullDevice.h

@@ -24,10 +24,10 @@ private:
     FullDevice();
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
     virtual StringView class_name() const override { return "FullDevice"; }
 };
 

Kernel/Devices/HID/KeyboardDevice.cpp

@@ -273,12 +273,12 @@ UNMAP_AFTER_INIT KeyboardDevice::~KeyboardDevice()
 {
 }
 
-bool KeyboardDevice::can_read(const FileDescription&, size_t) const
+bool KeyboardDevice::can_read(const OpenFileDescription&, size_t) const
 {
     return !m_queue.is_empty();
 }
 
-KResultOr<size_t> KeyboardDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> KeyboardDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     size_t nread = 0;
     SpinlockLocker lock(m_queue_lock);
@@ -306,12 +306,12 @@ KResultOr<size_t> KeyboardDevice::read(FileDescription&, u64, UserOrKernelBuffer
     return nread;
 }
 
-KResultOr<size_t> KeyboardDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t)
+KResultOr<size_t> KeyboardDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t)
 {
     return 0;
 }
 
-KResult KeyboardDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> arg)
+KResult KeyboardDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case KEYBOARD_IOCTL_GET_NUM_LOCK: {

Kernel/Devices/HID/KeyboardDevice.h

@@ -25,10 +25,10 @@ public:
     virtual ~KeyboardDevice() override;
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
     // ^HIDDevice
     virtual Type instrument_type() const override { return Type::Keyboard; }
@@ -37,7 +37,7 @@ public:
     virtual mode_t required_mode() const override { return 0440; }
 
     // ^File
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
 
     virtual String device_name() const override { return String::formatted("keyboard{}", minor()); }
 

Kernel/Devices/HID/MouseDevice.cpp

@@ -18,13 +18,13 @@ MouseDevice::~MouseDevice()
 {
 }
 
-bool MouseDevice::can_read(const FileDescription&, size_t) const
+bool MouseDevice::can_read(const OpenFileDescription&, size_t) const
 {
     SpinlockLocker lock(m_queue_lock);
     return !m_queue.is_empty();
 }
 
-KResultOr<size_t> MouseDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> MouseDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     VERIFY(size > 0);
     size_t nread = 0;
@@ -48,7 +48,7 @@ KResultOr<size_t> MouseDevice::read(FileDescription&, u64, UserOrKernelBuffer& b
     return nread;
 }
 
-KResultOr<size_t> MouseDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t)
+KResultOr<size_t> MouseDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t)
 {
     return 0;
 }

Kernel/Devices/HID/MouseDevice.h

@@ -23,10 +23,10 @@ public:
     virtual ~MouseDevice() override;
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
     // ^HIDDevice
     virtual Type instrument_type() const override { return Type::Mouse; }

Kernel/Devices/KCOVDevice.cpp

@@ -8,7 +8,7 @@
 #include <AK/NonnullOwnPtr.h>
 #include <Kernel/Devices/KCOVDevice.h>
 #include <Kernel/Devices/KCOVInstance.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <LibC/sys/ioctl_numbers.h>
 
 #include <Kernel/Panic.h>
@@ -61,7 +61,7 @@ void KCOVDevice::free_process()
     delete kcov_instance;
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> KCOVDevice::open(int options)
+KResultOr<NonnullRefPtr<OpenFileDescription>> KCOVDevice::open(int options)
 {
     auto pid = Process::current().pid();
     if (proc_instance->get(pid).has_value())
@@ -73,7 +73,7 @@ KResultOr<NonnullRefPtr<FileDescription>> KCOVDevice::open(int options)
     return File::open(options);
 }
 
-KResult KCOVDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> arg)
+KResult KCOVDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     KResult return_value = KSuccess;
     auto thread = Thread::current();
@@ -127,7 +127,7 @@ KResult KCOVDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> a
     return return_value;
 }
 
-KResultOr<Memory::Region*> KCOVDevice::mmap(Process& process, FileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+KResultOr<Memory::Region*> KCOVDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     auto pid = process.pid();
     auto maybe_kcov_instance = proc_instance->get(pid);

Kernel/Devices/KCOVDevice.h

@@ -22,8 +22,8 @@ public:
     static void free_process();
 
     // ^File
-    KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
-    KResultOr<NonnullRefPtr<FileDescription>> open(int options) override;
+    KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
 
     // ^Device
     virtual mode_t required_mode() const override { return 0660; }
@@ -32,12 +32,12 @@ public:
 protected:
     virtual StringView class_name() const override { return "KCOVDevice"; }
 
-    virtual bool can_read(const FileDescription&, size_t) const override final { return true; }
+    virtual bool can_read(const OpenFileDescription&, size_t) const override final { return true; }
-    virtual bool can_write(const FileDescription&, size_t) const override final { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override final { return true; }
     virtual void start_request(AsyncBlockDeviceRequest& request) override final { request.complete(AsyncDeviceRequest::Failure); }
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
 
 private:
     KCOVDevice();

Kernel/Devices/MemoryDevice.cpp

@@ -27,17 +27,17 @@ UNMAP_AFTER_INIT MemoryDevice::~MemoryDevice()
 {
 }
 
-KResultOr<size_t> MemoryDevice::read(FileDescription&, u64, UserOrKernelBuffer&, size_t)
+KResultOr<size_t> MemoryDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
 {
     TODO();
 }
 
-void MemoryDevice::did_seek(FileDescription&, off_t)
+void MemoryDevice::did_seek(OpenFileDescription&, off_t)
 {
     TODO();
 }
 
-KResultOr<Memory::Region*> MemoryDevice::mmap(Process& process, FileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+KResultOr<Memory::Region*> MemoryDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     auto viewed_address = PhysicalAddress(offset);
 

Kernel/Devices/MemoryDevice.h

@@ -19,7 +19,7 @@ public:
     static NonnullRefPtr<MemoryDevice> must_create();
     ~MemoryDevice();
 
-    virtual KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
 
     // ^Device
     virtual mode_t required_mode() const override { return 0660; }
@@ -28,13 +28,13 @@ public:
 private:
     MemoryDevice();
     virtual StringView class_name() const override { return "MemoryDevice"; }
-    virtual bool can_read(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
-    virtual bool can_write(const FileDescription&, size_t) const override { return false; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return false; }
     virtual bool is_seekable() const override { return true; }
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
 
-    virtual void did_seek(FileDescription&, off_t) override;
+    virtual void did_seek(OpenFileDescription&, off_t) override;
 
     bool is_allowed_range(PhysicalAddress, Memory::VirtualRange const&) const;
 };

Kernel/Devices/NullDevice.cpp

@@ -31,17 +31,17 @@ UNMAP_AFTER_INIT NullDevice::~NullDevice()
 {
 }
 
-bool NullDevice::can_read(const FileDescription&, size_t) const
+bool NullDevice::can_read(const OpenFileDescription&, size_t) const
 {
     return true;
 }
 
-KResultOr<size_t> NullDevice::read(FileDescription&, u64, UserOrKernelBuffer&, size_t)
+KResultOr<size_t> NullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
 {
     return 0;
 }
 
-KResultOr<size_t> NullDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t buffer_size)
+KResultOr<size_t> NullDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t buffer_size)
 {
     return buffer_size;
 }

Kernel/Devices/NullDevice.h

@@ -25,10 +25,10 @@ public:
 
 private:
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual StringView class_name() const override { return "NullDevice"; }
     virtual bool is_seekable() const override { return true; }
 };

Kernel/Devices/RandomDevice.cpp

@@ -24,12 +24,12 @@ UNMAP_AFTER_INIT RandomDevice::~RandomDevice()
 {
 }
 
-bool RandomDevice::can_read(const FileDescription&, size_t) const
+bool RandomDevice::can_read(const OpenFileDescription&, size_t) const
 {
     return true;
 }
 
-KResultOr<size_t> RandomDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> RandomDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     return buffer.write_buffered<256>(size, [&](Bytes bytes) {
         get_good_random_bytes(bytes);
@@ -37,7 +37,7 @@ KResultOr<size_t> RandomDevice::read(FileDescription&, u64, UserOrKernelBuffer&
     });
 }
 
-KResultOr<size_t> RandomDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t size)
+KResultOr<size_t> RandomDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
 {
     // FIXME: Use input for entropy? I guess that could be a neat feature?
     return size;

Kernel/Devices/RandomDevice.h

@@ -24,10 +24,10 @@ private:
     RandomDevice();
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
     virtual StringView class_name() const override { return "RandomDevice"; }
 };
 

Kernel/Devices/SB16.cpp

@@ -122,7 +122,7 @@ UNMAP_AFTER_INIT void SB16::initialize()
     set_sample_rate(m_sample_rate);
 }
 
-KResult SB16::ioctl(FileDescription&, unsigned request, Userspace<void*> arg)
+KResult SB16::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case SOUNDCARD_IOCTL_GET_SAMPLE_RATE: {
@@ -190,12 +190,12 @@ void SB16::set_irq_line(u8 irq_number)
     change_irq_number(irq_number);
 }
 
-bool SB16::can_read(FileDescription const&, size_t) const
+bool SB16::can_read(OpenFileDescription const&, size_t) const
 {
     return false;
 }
 
-KResultOr<size_t> SB16::read(FileDescription&, u64, UserOrKernelBuffer&, size_t)
+KResultOr<size_t> SB16::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
 {
     return 0;
 }
@@ -255,7 +255,7 @@ void SB16::wait_for_irq()
     disable_irq();
 }
 
-KResultOr<size_t> SB16::write(FileDescription&, u64, UserOrKernelBuffer const& data, size_t length)
+KResultOr<size_t> SB16::write(OpenFileDescription&, u64, UserOrKernelBuffer const& data, size_t length)
 {
     if (!m_dma_region) {
         auto page = MM.allocate_supervisor_physical_page();

Kernel/Devices/SB16.h

@@ -27,10 +27,10 @@ public:
     static SB16& the();
 
     // ^CharacterDevice
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
     virtual StringView purpose() const override { return class_name(); }
 
@@ -38,7 +38,7 @@ public:
     virtual mode_t required_mode() const override { return 0220; }
     virtual String device_name() const override { return "audio"; }
 
-    virtual KResult ioctl(FileDescription&, unsigned, Userspace<void*>) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned, Userspace<void*>) override;
 
 private:
     // ^IRQHandler

Kernel/Devices/SerialDevice.cpp

@@ -49,12 +49,12 @@ UNMAP_AFTER_INIT SerialDevice::~SerialDevice()
 {
 }
 
-bool SerialDevice::can_read(const FileDescription&, size_t) const
+bool SerialDevice::can_read(const OpenFileDescription&, size_t) const
 {
     return (get_line_status() & DataReady) != 0;
 }
 
-KResultOr<size_t> SerialDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> SerialDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (!size)
         return 0;
@@ -70,12 +70,12 @@ KResultOr<size_t> SerialDevice::read(FileDescription&, u64, UserOrKernelBuffer&
     });
 }
 
-bool SerialDevice::can_write(const FileDescription&, size_t) const
+bool SerialDevice::can_write(const OpenFileDescription&, size_t) const
 {
     return (get_line_status() & EmptyTransmitterHoldingRegister) != 0;
 }
 
-KResultOr<size_t> SerialDevice::write(FileDescription& description, u64, const UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> SerialDevice::write(OpenFileDescription& description, u64, const UserOrKernelBuffer& buffer, size_t size)
 {
     if (!size)
         return 0;

Kernel/Devices/SerialDevice.h

@@ -19,10 +19,10 @@ public:
     virtual ~SerialDevice() override;
 
     // ^CharacterDevice
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
 
     void put_char(char);
 

Kernel/Devices/ZeroDevice.cpp

@@ -24,18 +24,18 @@ UNMAP_AFTER_INIT ZeroDevice::~ZeroDevice()
 {
 }
 
-bool ZeroDevice::can_read(const FileDescription&, size_t) const
+bool ZeroDevice::can_read(const OpenFileDescription&, size_t) const
 {
     return true;
 }
 
-KResultOr<size_t> ZeroDevice::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> ZeroDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     TRY(buffer.memset(0, size));
     return size;
 }
 
-KResultOr<size_t> ZeroDevice::write(FileDescription&, u64, const UserOrKernelBuffer&, size_t size)
+KResultOr<size_t> ZeroDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
 {
     return size;
 }

Kernel/Devices/ZeroDevice.h

@@ -23,10 +23,10 @@ public:
 private:
     ZeroDevice();
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
     virtual StringView class_name() const override { return "ZeroDevice"; }
 };
 

Kernel/FileSystem/AnonymousFile.cpp

@@ -19,7 +19,7 @@ AnonymousFile::~AnonymousFile()
 {
 }
 
-KResultOr<Memory::Region*> AnonymousFile::mmap(Process& process, FileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+KResultOr<Memory::Region*> AnonymousFile::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     if (offset != 0)
         return EINVAL;

Kernel/FileSystem/AnonymousFile.h

@@ -20,15 +20,15 @@ public:
 
     virtual ~AnonymousFile() override;
 
-    virtual KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
 
 private:
     virtual StringView class_name() const override { return "AnonymousFile"; }
-    virtual String absolute_path(const FileDescription&) const override { return ":anonymous-file:"; }
+    virtual String absolute_path(const OpenFileDescription&) const override { return ":anonymous-file:"; }
-    virtual bool can_read(const FileDescription&, size_t) const override { return false; }
+    virtual bool can_read(const OpenFileDescription&, size_t) const override { return false; }
-    virtual bool can_write(const FileDescription&, size_t) const override { return false; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return false; }
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
 
     explicit AnonymousFile(NonnullRefPtr<Memory::AnonymousVMObject>);
 

Kernel/FileSystem/BlockBasedFileSystem.cpp

@@ -104,7 +104,7 @@ private:
     bool m_dirty { false };
 };
 
-BlockBasedFileSystem::BlockBasedFileSystem(FileDescription& file_description)
+BlockBasedFileSystem::BlockBasedFileSystem(OpenFileDescription& file_description)
     : FileBackedFileSystem(file_description)
 {
     VERIFY(file_description.file().is_seekable());

Kernel/FileSystem/BlockBasedFileSystem.h

@@ -24,7 +24,7 @@ public:
     void flush_writes_impl();
 
 protected:
-    explicit BlockBasedFileSystem(FileDescription&);
+    explicit BlockBasedFileSystem(OpenFileDescription&);
 
     KResult read_block(BlockIndex, UserOrKernelBuffer*, size_t count, size_t offset = 0, bool allow_cache = true) const;
     KResult read_blocks(BlockIndex, unsigned count, UserOrKernelBuffer&, bool allow_cache = true) const;

Kernel/FileSystem/DevFS.cpp

@@ -80,7 +80,7 @@ DevFSInode::DevFSInode(DevFS& fs)
 {
 }
 
-KResultOr<size_t> DevFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const
+KResultOr<size_t> DevFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
@@ -99,7 +99,7 @@ void DevFSInode::flush_metadata()
 {
 }
 
-KResultOr<size_t> DevFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*)
+KResultOr<size_t> DevFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     VERIFY_NOT_REACHED();
 }
@@ -149,7 +149,7 @@ DevFSLinkInode::DevFSLinkInode(DevFS& fs, NonnullOwnPtr<KString> name)
 {
 }
 
-KResultOr<size_t> DevFSLinkInode::read_bytes(off_t offset, size_t, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> DevFSLinkInode::read_bytes(off_t offset, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(offset == 0);
@@ -170,7 +170,7 @@ InodeMetadata DevFSLinkInode::metadata() const
     return metadata;
 }
 
-KResultOr<size_t> DevFSLinkInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, FileDescription*)
+KResultOr<size_t> DevFSLinkInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription*)
 {
     auto new_string = TRY(buffer.try_copy_into_kstring(count));
 
@@ -326,7 +326,7 @@ StringView DevFSDeviceInode::name() const
     return m_name->view();
 }
 
-KResultOr<size_t> DevFSDeviceInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
+KResultOr<size_t> DevFSDeviceInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(!!description);
@@ -352,7 +352,7 @@ InodeMetadata DevFSDeviceInode::metadata() const
     metadata.minor_device = m_attached_device->minor();
     return metadata;
 }
-KResultOr<size_t> DevFSDeviceInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, FileDescription* description)
+KResultOr<size_t> DevFSDeviceInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* description)
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(!!description);

Kernel/FileSystem/DevFS.h

@@ -53,11 +53,11 @@ public:
 
 protected:
     DevFSInode(DevFS&);
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     virtual void flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
     virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
     virtual KResult remove_child(const StringView& name) override;
@@ -77,9 +77,9 @@ public:
 private:
     DevFSDeviceInode(DevFS&, Device const&, NonnullOwnPtr<KString> name);
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
     virtual KResult chown(UserID, GroupID) override;
 
     NonnullRefPtr<Device> m_attached_device;
@@ -100,9 +100,9 @@ public:
 protected:
     DevFSLinkInode(DevFS&, NonnullOwnPtr<KString>);
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
 
     NonnullOwnPtr<KString> m_name;
     OwnPtr<KString> m_link;

Kernel/FileSystem/DevPtsFS.cpp

@@ -84,12 +84,12 @@ DevPtsFSInode::~DevPtsFSInode()
 {
 }
 
-KResultOr<size_t> DevPtsFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const
+KResultOr<size_t> DevPtsFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<size_t> DevPtsFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*)
+KResultOr<size_t> DevPtsFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     VERIFY_NOT_REACHED();
 }

Kernel/FileSystem/DevPtsFS.h

@@ -47,12 +47,12 @@ private:
     DevPtsFSInode(DevPtsFS&, InodeIndex, SlavePTY*);
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     virtual void flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
     virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
     virtual KResult remove_child(const StringView& name) override;

Kernel/FileSystem/Ext2FileSystem.cpp

@@ -12,7 +12,7 @@
 #include <Kernel/Debug.h>
 #include <Kernel/Devices/BlockDevice.h>
 #include <Kernel/FileSystem/Ext2FileSystem.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/ext2_fs.h>
 #include <Kernel/Process.h>
 #include <Kernel/UnixTypes.h>
@@ -54,12 +54,12 @@ static unsigned divide_rounded_up(unsigned a, unsigned b)
     return (a / b) + (a % b != 0);
 }
 
-KResultOr<NonnullRefPtr<Ext2FS>> Ext2FS::try_create(FileDescription& file_description)
+KResultOr<NonnullRefPtr<Ext2FS>> Ext2FS::try_create(OpenFileDescription& file_description)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) Ext2FS(file_description));
 }
 
-Ext2FS::Ext2FS(FileDescription& file_description)
+Ext2FS::Ext2FS(OpenFileDescription& file_description)
     : BlockBasedFileSystem(file_description)
 {
 }
@@ -827,7 +827,7 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FS::get_inode(InodeIdentifier inode) const
     return new_inode;
 }
 
-KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
+KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     MutexLocker inode_locker(m_inode_lock);
     VERIFY(offset >= 0);
@@ -965,7 +965,7 @@ KResult Ext2FSInode::resize(u64 new_size)
     return KSuccess;
 }
 
-KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& data, FileDescription* description)
+KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& data, OpenFileDescription* description)
 {
     VERIFY(offset >= 0);
 

Kernel/FileSystem/Ext2FileSystem.h

@@ -38,12 +38,12 @@ public:
 
 private:
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     virtual void flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
     virtual KResult add_child(Inode& child, const StringView& name, mode_t) override;
     virtual KResult remove_child(const StringView& name) override;
@@ -89,7 +89,7 @@ public:
         FileSize64bits = 1 << 1,
     };
 
-    static KResultOr<NonnullRefPtr<Ext2FS>> try_create(FileDescription&);
+    static KResultOr<NonnullRefPtr<Ext2FS>> try_create(OpenFileDescription&);
 
     virtual ~Ext2FS() override;
     virtual KResult initialize() override;
@@ -110,7 +110,7 @@ public:
 private:
     TYPEDEF_DISTINCT_ORDERED_ID(unsigned, GroupIndex);
 
-    explicit Ext2FS(FileDescription&);
+    explicit Ext2FS(OpenFileDescription&);
 
     const ext2_super_block& super_block() const { return m_super_block; }
     const ext2_group_desc& group_descriptor(GroupIndex) const;

Kernel/FileSystem/FIFO.cpp

@@ -7,7 +7,7 @@
 #include <AK/Atomic.h>
 #include <AK/StdLibExtras.h>
 #include <Kernel/FileSystem/FIFO.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Locking/Mutex.h>
 #include <Kernel/Process.h>
 #include <Kernel/Thread.h>
@@ -24,15 +24,15 @@ RefPtr<FIFO> FIFO::try_create(UserID uid)
     return {};
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> FIFO::open_direction(FIFO::Direction direction)
+KResultOr<NonnullRefPtr<OpenFileDescription>> FIFO::open_direction(FIFO::Direction direction)
 {
-    auto description = TRY(FileDescription::try_create(*this));
+    auto description = TRY(OpenFileDescription::try_create(*this));
     attach(direction);
     description->set_fifo_direction({}, direction);
     return description;
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> FIFO::open_direction_blocking(FIFO::Direction direction)
+KResultOr<NonnullRefPtr<OpenFileDescription>> FIFO::open_direction_blocking(FIFO::Direction direction)
 {
     MutexLocker locker(m_open_lock);
 
@@ -101,17 +101,17 @@ void FIFO::detach(Direction direction)
     evaluate_block_conditions();
 }
 
-bool FIFO::can_read(const FileDescription&, size_t) const
+bool FIFO::can_read(const OpenFileDescription&, size_t) const
 {
     return !m_buffer->is_empty() || !m_writers;
 }
 
-bool FIFO::can_write(const FileDescription&, size_t) const
+bool FIFO::can_write(const OpenFileDescription&, size_t) const
 {
     return m_buffer->space_for_writing() || !m_readers;
 }
 
-KResultOr<size_t> FIFO::read(FileDescription& fd, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> FIFO::read(OpenFileDescription& fd, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (m_buffer->is_empty()) {
         if (!m_writers)
@@ -122,7 +122,7 @@ KResultOr<size_t> FIFO::read(FileDescription& fd, u64, UserOrKernelBuffer& buffe
     return m_buffer->read(buffer, size);
 }
 
-KResultOr<size_t> FIFO::write(FileDescription& fd, u64, const UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> FIFO::write(OpenFileDescription& fd, u64, const UserOrKernelBuffer& buffer, size_t size)
 {
     if (!m_readers) {
         Thread::current()->send_signal(SIGPIPE, &Process::current());
@@ -134,7 +134,7 @@ KResultOr<size_t> FIFO::write(FileDescription& fd, u64, const UserOrKernelBuffer
     return m_buffer->write(buffer, size);
 }
 
-String FIFO::absolute_path(const FileDescription&) const
+String FIFO::absolute_path(const OpenFileDescription&) const
 {
     return String::formatted("fifo:{}", m_fifo_id);
 }

Kernel/FileSystem/FIFO.h

@@ -14,7 +14,7 @@
 
 namespace Kernel {
 
-class FileDescription;
+class OpenFileDescription;
 
 class FIFO final : public File {
 public:
@@ -29,8 +29,8 @@ public:
 
     UserID uid() const { return m_uid; }
 
-    KResultOr<NonnullRefPtr<FileDescription>> open_direction(Direction);
+    KResultOr<NonnullRefPtr<OpenFileDescription>> open_direction(Direction);
-    KResultOr<NonnullRefPtr<FileDescription>> open_direction_blocking(Direction);
+    KResultOr<NonnullRefPtr<OpenFileDescription>> open_direction_blocking(Direction);
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Woverloaded-virtual"
@@ -40,12 +40,12 @@ public:
 
 private:
     // ^File
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual KResult stat(::stat&) const override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual String absolute_path(const FileDescription&) const override;
+    virtual String absolute_path(const OpenFileDescription&) const override;
     virtual StringView class_name() const override { return "FIFO"; }
     virtual bool is_fifo() const override { return true; }
 

Kernel/FileSystem/File.cpp

@@ -7,7 +7,7 @@
 #include <AK/StringView.h>
 #include <AK/Userspace.h>
 #include <Kernel/FileSystem/File.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Process.h>
 
 namespace Kernel {
@@ -28,9 +28,9 @@ bool File::unref() const
     return true;
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> File::open(int options)
+KResultOr<NonnullRefPtr<OpenFileDescription>> File::open(int options)
 {
-    auto description = FileDescription::try_create(*this);
+    auto description = OpenFileDescription::try_create(*this);
     if (!description.is_error()) {
         description.value()->set_rw_mode(options);
         description.value()->set_file_flags(options);
@@ -43,23 +43,23 @@ KResult File::close()
     return KSuccess;
 }
 
-KResult File::ioctl(FileDescription&, unsigned, Userspace<void*>)
+KResult File::ioctl(OpenFileDescription&, unsigned, Userspace<void*>)
 {
     return ENOTTY;
 }
 
-KResultOr<Memory::Region*> File::mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64, int, bool)
+KResultOr<Memory::Region*> File::mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64, int, bool)
 {
     return ENODEV;
 }
 
-KResult File::attach(FileDescription&)
+KResult File::attach(OpenFileDescription&)
 {
     m_attach_count++;
     return KSuccess;
 }
 
-void File::detach(FileDescription&)
+void File::detach(OpenFileDescription&)
 {
     m_attach_count--;
 }

Kernel/FileSystem/File.h

@@ -43,7 +43,7 @@ public:
     }
 };
 
-// File is the base class for anything that can be referenced by a FileDescription.
+// File is the base class for anything that can be referenced by a OpenFileDescription.
 //
 // The most important functions in File are:
 //
@@ -77,26 +77,26 @@ public:
     virtual bool unref() const;
     virtual ~File();
 
-    virtual KResultOr<NonnullRefPtr<FileDescription>> open(int options);
+    virtual KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options);
     virtual KResult close();
 
-    virtual bool can_read(const FileDescription&, size_t) const = 0;
+    virtual bool can_read(const OpenFileDescription&, size_t) const = 0;
-    virtual bool can_write(const FileDescription&, size_t) const = 0;
+    virtual bool can_write(const OpenFileDescription&, size_t) const = 0;
 
-    virtual KResult attach(FileDescription&);
+    virtual KResult attach(OpenFileDescription&);
-    virtual void detach(FileDescription&);
+    virtual void detach(OpenFileDescription&);
-    virtual void did_seek(FileDescription&, off_t) { }
+    virtual void did_seek(OpenFileDescription&, off_t) { }
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) = 0;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) = 0;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) = 0;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) = 0;
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg);
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg);
-    virtual KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
+    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
     virtual KResult stat(::stat&) const { return EBADF; }
 
-    virtual String absolute_path(const FileDescription&) const = 0;
+    virtual String absolute_path(const OpenFileDescription&) const = 0;
 
     virtual KResult truncate(u64) { return EINVAL; }
-    virtual KResult chown(FileDescription&, UserID, GroupID) { return EBADF; }
+    virtual KResult chown(OpenFileDescription&, UserID, GroupID) { return EBADF; }
-    virtual KResult chmod(FileDescription&, mode_t) { return EBADF; }
+    virtual KResult chmod(OpenFileDescription&, mode_t) { return EBADF; }
 
     virtual StringView class_name() const = 0;
 

Kernel/FileSystem/FileBackedFileSystem.cpp

@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-FileBackedFileSystem::FileBackedFileSystem(FileDescription& file_description)
+FileBackedFileSystem::FileBackedFileSystem(OpenFileDescription& file_description)
     : m_file_description(file_description)
 {
 }

Kernel/FileSystem/FileBackedFileSystem.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 
 namespace Kernel {
 
@@ -16,17 +16,17 @@ public:
     virtual ~FileBackedFileSystem() override;
 
     File& file() { return m_file_description->file(); }
-    FileDescription& file_description() { return *m_file_description; }
+    OpenFileDescription& file_description() { return *m_file_description; }
     const File& file() const { return m_file_description->file(); }
-    FileDescription& file_description() const { return *m_file_description; }
+    OpenFileDescription& file_description() const { return *m_file_description; }
 
 protected:
-    explicit FileBackedFileSystem(FileDescription&);
+    explicit FileBackedFileSystem(OpenFileDescription&);
 
 private:
     virtual bool is_file_backed() const override { return true; }
 
-    mutable NonnullRefPtr<FileDescription> m_file_description;
+    mutable NonnullRefPtr<OpenFileDescription> m_file_description;
 };
 
 }

Kernel/FileSystem/ISO9660FileSystem.cpp

@@ -171,12 +171,12 @@ private:
     Vector<DirectoryState> m_directory_stack;
 };
 
-KResultOr<NonnullRefPtr<ISO9660FS>> ISO9660FS::try_create(FileDescription& description)
+KResultOr<NonnullRefPtr<ISO9660FS>> ISO9660FS::try_create(OpenFileDescription& description)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ISO9660FS(description));
 }
 
-ISO9660FS::ISO9660FS(FileDescription& description)
+ISO9660FS::ISO9660FS(OpenFileDescription& description)
     : BlockBasedFileSystem(description)
 {
     set_block_size(logical_sector_size);
@@ -415,7 +415,7 @@ u32 ISO9660FS::calculate_directory_entry_cache_key(ISO::DirectoryRecordHeader co
     return LittleEndian { record.extent_location.little };
 }
 
-KResultOr<size_t> ISO9660Inode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> ISO9660Inode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     MutexLocker inode_locker(m_inode_lock);
 
@@ -514,7 +514,7 @@ void ISO9660Inode::flush_metadata()
 {
 }
 
-KResultOr<size_t> ISO9660Inode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*)
+KResultOr<size_t> ISO9660Inode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     return EROFS;
 }

Kernel/FileSystem/ISO9660FileSystem.h

@@ -305,7 +305,7 @@ public:
         }
     };
 
-    static KResultOr<NonnullRefPtr<ISO9660FS>> try_create(FileDescription&);
+    static KResultOr<NonnullRefPtr<ISO9660FS>> try_create(OpenFileDescription&);
 
     virtual ~ISO9660FS() override;
     virtual KResult initialize() override;
@@ -320,7 +320,7 @@ public:
     KResultOr<NonnullRefPtr<DirectoryEntry>> directory_entry_for_record(Badge<ISO9660DirectoryIterator>, ISO::DirectoryRecordHeader const* record);
 
 private:
-    ISO9660FS(FileDescription&);
+    ISO9660FS(OpenFileDescription&);
 
     KResult parse_volume_set();
     KResult create_root_inode();
@@ -347,12 +347,12 @@ public:
     ISO9660FS const& fs() const { return static_cast<ISO9660FS const&>(Inode::fs()); }
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     virtual void flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
     virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
     virtual KResult remove_child(const StringView& name) override;

Kernel/FileSystem/Inode.cpp

@@ -11,9 +11,9 @@
 #include <AK/StringView.h>
 #include <Kernel/API/InodeWatcherEvent.h>
 #include <Kernel/FileSystem/Custody.h>
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/FileSystem/InodeWatcher.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/KBufferBuilder.h>
 #include <Kernel/Memory/SharedInodeVMObject.h>
@@ -45,7 +45,7 @@ void Inode::sync()
     }
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(FileDescription* description) const
+KResultOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(OpenFileDescription* description) const
 {
     KBufferBuilder builder;
 
@@ -267,7 +267,7 @@ static inline bool range_overlap(T start1, T len1, T start2, T len2)
     return ((start1 < start2 + len2) || len2 == 0) && ((start2 < start1 + len1) || len1 == 0);
 }
 
-static inline KResult normalize_flock(FileDescription const& description, flock& lock)
+static inline KResult normalize_flock(OpenFileDescription const& description, flock& lock)
 {
     off_t start;
     switch (lock.l_whence) {
@@ -287,7 +287,7 @@ static inline KResult normalize_flock(FileDescription const& description, flock&
     return KSuccess;
 }
 
-KResult Inode::can_apply_flock(FileDescription const& description, flock const& new_lock) const
+KResult Inode::can_apply_flock(OpenFileDescription const& description, flock const& new_lock) const
 {
     VERIFY(new_lock.l_whence == SEEK_SET);
 
@@ -314,7 +314,7 @@ KResult Inode::can_apply_flock(FileDescription const& description, flock const&
     return KSuccess;
 }
 
-KResult Inode::apply_flock(Process const& process, FileDescription const& description, Userspace<flock const*> input_lock)
+KResult Inode::apply_flock(Process const& process, OpenFileDescription const& description, Userspace<flock const*> input_lock)
 {
     flock new_lock = {};
     TRY(copy_from_user(&new_lock, input_lock));
@@ -338,7 +338,7 @@ KResult Inode::apply_flock(Process const& process, FileDescription const& descri
     return KSuccess;
 }
 
-KResult Inode::get_flock(FileDescription const& description, Userspace<flock*> reference_lock) const
+KResult Inode::get_flock(OpenFileDescription const& description, Userspace<flock*> reference_lock) const
 {
     flock lookup = {};
     TRY(copy_from_user(&lookup, reference_lock));
@@ -360,7 +360,7 @@ KResult Inode::get_flock(FileDescription const& description, Userspace<flock*> r
     return copy_to_user(reference_lock, &lookup);
 }
 
-void Inode::remove_flocks_for_description(FileDescription const& description)
+void Inode::remove_flocks_for_description(OpenFileDescription const& description)
 {
     MutexLocker locker(m_inode_lock);
 

Kernel/FileSystem/Inode.h

@@ -46,15 +46,15 @@ public:
     InodeIdentifier identifier() const { return { fsid(), index() }; }
     virtual InodeMetadata metadata() const = 0;
 
-    KResultOr<NonnullOwnPtr<KBuffer>> read_entire(FileDescription* = nullptr) const;
+    KResultOr<NonnullOwnPtr<KBuffer>> read_entire(OpenFileDescription* = nullptr) const;
 
-    virtual KResult attach(FileDescription&) { return KSuccess; }
+    virtual KResult attach(OpenFileDescription&) { return KSuccess; }
-    virtual void detach(FileDescription&) { }
+    virtual void detach(OpenFileDescription&) { }
-    virtual void did_seek(FileDescription&, off_t) { }
+    virtual void did_seek(OpenFileDescription&, off_t) { }
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const = 0;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const = 0;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const = 0;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) = 0;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, FileDescription*) = 0;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) = 0;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) = 0;
     virtual KResult add_child(Inode&, const StringView& name, mode_t) = 0;
     virtual KResult remove_child(const StringView& name) = 0;
@@ -70,7 +70,7 @@ public:
     bool bind_socket(LocalSocket&);
     bool unbind_socket();
 
-    virtual FileDescription* preopen_fd() { return nullptr; };
+    virtual OpenFileDescription* preopen_fd() { return nullptr; };
 
     bool is_metadata_dirty() const { return m_metadata_dirty; }
 
@@ -96,10 +96,10 @@ public:
 
     NonnullRefPtr<FIFO> fifo();
 
-    KResult can_apply_flock(FileDescription const&, flock const&) const;
+    KResult can_apply_flock(OpenFileDescription const&, flock const&) const;
-    KResult apply_flock(Process const&, FileDescription const&, Userspace<flock const*>);
+    KResult apply_flock(Process const&, OpenFileDescription const&, Userspace<flock const*>);
-    KResult get_flock(FileDescription const&, Userspace<flock*>) const;
+    KResult get_flock(OpenFileDescription const&, Userspace<flock*>) const;
-    void remove_flocks_for_description(FileDescription const&);
+    void remove_flocks_for_description(OpenFileDescription const&);
 
 protected:
     Inode(FileSystem&, InodeIndex);
@@ -127,7 +127,7 @@ private:
         short type;
         off_t start;
         off_t len;
-        FileDescription const* owner;
+        OpenFileDescription const* owner;
         pid_t pid;
     };
 

Kernel/FileSystem/InodeFile.cpp

@@ -5,9 +5,9 @@
  */
 
 #include <AK/StringView.h>
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/FileSystem/InodeFile.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/Memory/PrivateInodeVMObject.h>
 #include <Kernel/Memory/SharedInodeVMObject.h>
@@ -26,7 +26,7 @@ InodeFile::~InodeFile()
 {
 }
 
-KResultOr<size_t> InodeFile::read(FileDescription& description, u64 offset, UserOrKernelBuffer& buffer, size_t count)
+KResultOr<size_t> InodeFile::read(OpenFileDescription& description, u64 offset, UserOrKernelBuffer& buffer, size_t count)
 {
     if (Checked<off_t>::addition_would_overflow(offset, count))
         return EOVERFLOW;
@@ -39,7 +39,7 @@ KResultOr<size_t> InodeFile::read(FileDescription& description, u64 offset, User
     return nread;
 }
 
-KResultOr<size_t> InodeFile::write(FileDescription& description, u64 offset, const UserOrKernelBuffer& data, size_t count)
+KResultOr<size_t> InodeFile::write(OpenFileDescription& description, u64 offset, const UserOrKernelBuffer& data, size_t count)
 {
     if (Checked<off_t>::addition_would_overflow(offset, count))
         return EOVERFLOW;
@@ -55,7 +55,7 @@ KResultOr<size_t> InodeFile::write(FileDescription& description, u64 offset, con
     return nwritten;
 }
 
-KResult InodeFile::ioctl(FileDescription& description, unsigned request, Userspace<void*> arg)
+KResult InodeFile::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case FIBMAP: {
@@ -81,7 +81,7 @@ KResult InodeFile::ioctl(FileDescription& description, unsigned request, Userspa
     }
 }
 
-KResultOr<Memory::Region*> InodeFile::mmap(Process& process, FileDescription& description, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+KResultOr<Memory::Region*> InodeFile::mmap(Process& process, OpenFileDescription& description, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     // FIXME: If PROT_EXEC, check that the underlying file system isn't mounted noexec.
     RefPtr<Memory::InodeVMObject> vmobject;
@@ -92,7 +92,7 @@ KResultOr<Memory::Region*> InodeFile::mmap(Process& process, FileDescription& de
     return process.address_space().allocate_region_with_vmobject(range, vmobject.release_nonnull(), offset, description.absolute_path(), prot, shared);
 }
 
-String InodeFile::absolute_path(const FileDescription& description) const
+String InodeFile::absolute_path(const OpenFileDescription& description) const
 {
     VERIFY_NOT_REACHED();
     VERIFY(description.custody());
@@ -106,14 +106,14 @@ KResult InodeFile::truncate(u64 size)
     return KSuccess;
 }
 
-KResult InodeFile::chown(FileDescription& description, UserID uid, GroupID gid)
+KResult InodeFile::chown(OpenFileDescription& description, UserID uid, GroupID gid)
 {
     VERIFY(description.inode() == m_inode);
     VERIFY(description.custody());
     return VirtualFileSystem::the().chown(*description.custody(), uid, gid);
 }
 
-KResult InodeFile::chmod(FileDescription& description, mode_t mode)
+KResult InodeFile::chmod(OpenFileDescription& description, mode_t mode)
 {
     VERIFY(description.inode() == m_inode);
     VERIFY(description.custody());

Kernel/FileSystem/InodeFile.h

@@ -27,20 +27,20 @@ public:
     const Inode& inode() const { return *m_inode; }
     Inode& inode() { return *m_inode; }
 
-    virtual bool can_read(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
-    virtual KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
     virtual KResult stat(::stat& buffer) const override { return inode().metadata().stat(buffer); }
 
-    virtual String absolute_path(const FileDescription&) const override;
+    virtual String absolute_path(const OpenFileDescription&) const override;
 
     virtual KResult truncate(u64) override;
-    virtual KResult chown(FileDescription&, UserID, GroupID) override;
+    virtual KResult chown(OpenFileDescription&, UserID, GroupID) override;
-    virtual KResult chmod(FileDescription&, mode_t) override;
+    virtual KResult chmod(OpenFileDescription&, mode_t) override;
 
     virtual StringView class_name() const override { return "InodeFile"; }
 

Kernel/FileSystem/InodeWatcher.cpp

@@ -22,13 +22,13 @@ InodeWatcher::~InodeWatcher()
     (void)close();
 }
 
-bool InodeWatcher::can_read(const FileDescription&, size_t) const
+bool InodeWatcher::can_read(const OpenFileDescription&, size_t) const
 {
     MutexLocker locker(m_lock);
     return !m_queue.is_empty();
 }
 
-KResultOr<size_t> InodeWatcher::read(FileDescription&, u64, UserOrKernelBuffer& buffer, size_t buffer_size)
+KResultOr<size_t> InodeWatcher::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t buffer_size)
 {
     MutexLocker locker(m_lock);
     if (m_queue.is_empty())
@@ -81,7 +81,7 @@ KResult InodeWatcher::close()
     return KSuccess;
 }
 
-String InodeWatcher::absolute_path(const FileDescription&) const
+String InodeWatcher::absolute_path(const OpenFileDescription&) const
 {
     return String::formatted("InodeWatcher:({})", m_wd_to_watches.size());
 }

Kernel/FileSystem/InodeWatcher.h

@@ -43,14 +43,14 @@ public:
     static KResultOr<NonnullRefPtr<InodeWatcher>> try_create();
     virtual ~InodeWatcher() override;
 
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     // Can't write to an inode watcher.
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EIO; }
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EIO; }
     virtual KResult close() override;
 
-    virtual String absolute_path(const FileDescription&) const override;
+    virtual String absolute_path(const OpenFileDescription&) const override;
     virtual StringView class_name() const override { return "InodeWatcher"; };
     virtual bool is_inode_watcher() const override { return true; }
 

Kernel/FileSystem/OpenFileDescription.cpp

@@ -10,10 +10,10 @@
 #include <Kernel/Devices/BlockDevice.h>
 #include <Kernel/FileSystem/Custody.h>
 #include <Kernel/FileSystem/FIFO.h>
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/InodeFile.h>
 #include <Kernel/FileSystem/InodeWatcher.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Memory/MemoryManager.h>
 #include <Kernel/Net/Socket.h>
 #include <Kernel/Process.h>
@@ -24,24 +24,24 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<FileDescription>> FileDescription::try_create(Custody& custody)
+KResultOr<NonnullRefPtr<OpenFileDescription>> OpenFileDescription::try_create(Custody& custody)
 {
     auto inode_file = TRY(InodeFile::create(custody.inode()));
-    auto description = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) FileDescription(move(inode_file))));
+    auto description = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) OpenFileDescription(move(inode_file))));
 
     description->m_custody = custody;
     TRY(description->attach());
     return description;
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> FileDescription::try_create(File& file)
+KResultOr<NonnullRefPtr<OpenFileDescription>> OpenFileDescription::try_create(File& file)
 {
-    auto description = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) FileDescription(file)));
+    auto description = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) OpenFileDescription(file)));
     TRY(description->attach());
     return description;
 }
 
-FileDescription::FileDescription(File& file)
+OpenFileDescription::OpenFileDescription(File& file)
     : m_file(file)
 {
     if (file.is_inode())
@@ -50,7 +50,7 @@ FileDescription::FileDescription(File& file)
     m_is_directory = metadata().is_directory();
 }
 
-FileDescription::~FileDescription()
+OpenFileDescription::~OpenFileDescription()
 {
     m_file->detach(*this);
     if (is_fifo())
@@ -64,14 +64,14 @@ FileDescription::~FileDescription()
         m_inode->remove_flocks_for_description(*this);
 }
 
-KResult FileDescription::attach()
+KResult OpenFileDescription::attach()
 {
     if (m_inode)
         TRY(m_inode->attach(*this));
     return m_file->attach(*this);
 }
 
-Thread::FileBlocker::BlockFlags FileDescription::should_unblock(Thread::FileBlocker::BlockFlags block_flags) const
+Thread::FileBlocker::BlockFlags OpenFileDescription::should_unblock(Thread::FileBlocker::BlockFlags block_flags) const
 {
     using BlockFlags = Thread::FileBlocker::BlockFlags;
     BlockFlags unblock_flags = BlockFlags::None;
@@ -92,7 +92,7 @@ Thread::FileBlocker::BlockFlags FileDescription::should_unblock(Thread::FileBloc
     return unblock_flags;
 }
 
-KResult FileDescription::stat(::stat& buffer)
+KResult OpenFileDescription::stat(::stat& buffer)
 {
     MutexLocker locker(m_lock);
     // FIXME: This is due to the Device class not overriding File::stat().
@@ -101,7 +101,7 @@ KResult FileDescription::stat(::stat& buffer)
     return m_file->stat(buffer);
 }
 
-KResultOr<off_t> FileDescription::seek(off_t offset, int whence)
+KResultOr<off_t> OpenFileDescription::seek(off_t offset, int whence)
 {
     MutexLocker locker(m_lock);
     if (!m_file->is_seekable())
@@ -142,21 +142,21 @@ KResultOr<off_t> FileDescription::seek(off_t offset, int whence)
     return m_current_offset;
 }
 
-KResultOr<size_t> FileDescription::read(UserOrKernelBuffer& buffer, u64 offset, size_t count)
+KResultOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, u64 offset, size_t count)
 {
     if (Checked<u64>::addition_would_overflow(offset, count))
         return EOVERFLOW;
     return m_file->read(*this, offset, buffer, count);
 }
 
-KResultOr<size_t> FileDescription::write(u64 offset, UserOrKernelBuffer const& data, size_t data_size)
+KResultOr<size_t> OpenFileDescription::write(u64 offset, UserOrKernelBuffer const& data, size_t data_size)
 {
     if (Checked<u64>::addition_would_overflow(offset, data_size))
         return EOVERFLOW;
     return m_file->write(*this, offset, data, data_size);
 }
 
-KResultOr<size_t> FileDescription::read(UserOrKernelBuffer& buffer, size_t count)
+KResultOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, size_t count)
 {
     MutexLocker locker(m_lock);
     if (Checked<off_t>::addition_would_overflow(m_current_offset, count))
@@ -168,7 +168,7 @@ KResultOr<size_t> FileDescription::read(UserOrKernelBuffer& buffer, size_t count
     return nread;
 }
 
-KResultOr<size_t> FileDescription::write(const UserOrKernelBuffer& data, size_t size)
+KResultOr<size_t> OpenFileDescription::write(const UserOrKernelBuffer& data, size_t size)
 {
     MutexLocker locker(m_lock);
     if (Checked<off_t>::addition_would_overflow(m_current_offset, size))
@@ -180,17 +180,17 @@ KResultOr<size_t> FileDescription::write(const UserOrKernelBuffer& data, size_t
     return nwritten;
 }
 
-bool FileDescription::can_write() const
+bool OpenFileDescription::can_write() const
 {
     return m_file->can_write(*this, offset());
 }
 
-bool FileDescription::can_read() const
+bool OpenFileDescription::can_read() const
 {
     return m_file->can_read(*this, offset());
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> FileDescription::read_entire_file()
+KResultOr<NonnullOwnPtr<KBuffer>> OpenFileDescription::read_entire_file()
 {
     // HACK ALERT: (This entire function)
     VERIFY(m_file->is_inode());
@@ -198,7 +198,7 @@ KResultOr<NonnullOwnPtr<KBuffer>> FileDescription::read_entire_file()
     return m_inode->read_entire(this);
 }
 
-KResultOr<size_t> FileDescription::get_dir_entries(UserOrKernelBuffer& output_buffer, size_t size)
+KResultOr<size_t> OpenFileDescription::get_dir_entries(UserOrKernelBuffer& output_buffer, size_t size)
 {
     MutexLocker locker(m_lock, Mutex::Mode::Shared);
     if (!is_directory())
@@ -261,90 +261,90 @@ KResultOr<size_t> FileDescription::get_dir_entries(UserOrKernelBuffer& output_bu
     return size - remaining;
 }
 
-bool FileDescription::is_device() const
+bool OpenFileDescription::is_device() const
 {
     return m_file->is_device();
 }
 
-const Device* FileDescription::device() const
+const Device* OpenFileDescription::device() const
 {
     if (!is_device())
         return nullptr;
     return static_cast<const Device*>(m_file.ptr());
 }
 
-Device* FileDescription::device()
+Device* OpenFileDescription::device()
 {
     if (!is_device())
         return nullptr;
     return static_cast<Device*>(m_file.ptr());
 }
 
-bool FileDescription::is_tty() const
+bool OpenFileDescription::is_tty() const
 {
     return m_file->is_tty();
 }
 
-const TTY* FileDescription::tty() const
+const TTY* OpenFileDescription::tty() const
 {
     if (!is_tty())
         return nullptr;
     return static_cast<const TTY*>(m_file.ptr());
 }
 
-TTY* FileDescription::tty()
+TTY* OpenFileDescription::tty()
 {
     if (!is_tty())
         return nullptr;
     return static_cast<TTY*>(m_file.ptr());
 }
 
-bool FileDescription::is_inode_watcher() const
+bool OpenFileDescription::is_inode_watcher() const
 {
     return m_file->is_inode_watcher();
 }
 
-const InodeWatcher* FileDescription::inode_watcher() const
+const InodeWatcher* OpenFileDescription::inode_watcher() const
 {
     if (!is_inode_watcher())
         return nullptr;
     return static_cast<const InodeWatcher*>(m_file.ptr());
 }
 
-InodeWatcher* FileDescription::inode_watcher()
+InodeWatcher* OpenFileDescription::inode_watcher()
 {
     if (!is_inode_watcher())
         return nullptr;
     return static_cast<InodeWatcher*>(m_file.ptr());
 }
 
-bool FileDescription::is_master_pty() const
+bool OpenFileDescription::is_master_pty() const
 {
     return m_file->is_master_pty();
 }
 
-const MasterPTY* FileDescription::master_pty() const
+const MasterPTY* OpenFileDescription::master_pty() const
 {
     if (!is_master_pty())
         return nullptr;
     return static_cast<const MasterPTY*>(m_file.ptr());
 }
 
-MasterPTY* FileDescription::master_pty()
+MasterPTY* OpenFileDescription::master_pty()
 {
     if (!is_master_pty())
         return nullptr;
     return static_cast<MasterPTY*>(m_file.ptr());
 }
 
-KResult FileDescription::close()
+KResult OpenFileDescription::close()
 {
     if (m_file->attach_count() > 0)
         return KSuccess;
     return m_file->close();
 }
 
-KResultOr<NonnullOwnPtr<KString>> FileDescription::try_serialize_absolute_path()
+KResultOr<NonnullOwnPtr<KString>> OpenFileDescription::try_serialize_absolute_path()
 {
     if (m_custody)
         return m_custody->try_serialize_absolute_path();
@@ -352,64 +352,64 @@ KResultOr<NonnullOwnPtr<KString>> FileDescription::try_serialize_absolute_path()
     return KString::try_create(m_file->absolute_path(*this));
 }
 
-String FileDescription::absolute_path() const
+String OpenFileDescription::absolute_path() const
 {
     if (m_custody)
         return m_custody->absolute_path();
     return m_file->absolute_path(*this);
 }
 
-InodeMetadata FileDescription::metadata() const
+InodeMetadata OpenFileDescription::metadata() const
 {
     if (m_inode)
         return m_inode->metadata();
     return {};
 }
 
-KResultOr<Memory::Region*> FileDescription::mmap(Process& process, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+KResultOr<Memory::Region*> OpenFileDescription::mmap(Process& process, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     MutexLocker locker(m_lock);
     return m_file->mmap(process, *this, range, offset, prot, shared);
 }
 
-KResult FileDescription::truncate(u64 length)
+KResult OpenFileDescription::truncate(u64 length)
 {
     MutexLocker locker(m_lock);
     return m_file->truncate(length);
 }
 
-bool FileDescription::is_fifo() const
+bool OpenFileDescription::is_fifo() const
 {
     return m_file->is_fifo();
 }
 
-FIFO* FileDescription::fifo()
+FIFO* OpenFileDescription::fifo()
 {
     if (!is_fifo())
         return nullptr;
     return static_cast<FIFO*>(m_file.ptr());
 }
 
-bool FileDescription::is_socket() const
+bool OpenFileDescription::is_socket() const
 {
     return m_file->is_socket();
 }
 
-Socket* FileDescription::socket()
+Socket* OpenFileDescription::socket()
 {
     if (!is_socket())
         return nullptr;
     return static_cast<Socket*>(m_file.ptr());
 }
 
-const Socket* FileDescription::socket() const
+const Socket* OpenFileDescription::socket() const
 {
     if (!is_socket())
         return nullptr;
     return static_cast<const Socket*>(m_file.ptr());
 }
 
-void FileDescription::set_file_flags(u32 flags)
+void OpenFileDescription::set_file_flags(u32 flags)
 {
     MutexLocker locker(m_lock);
     m_is_blocking = !(flags & O_NONBLOCK);
@@ -418,24 +418,24 @@ void FileDescription::set_file_flags(u32 flags)
     m_file_flags = flags;
 }
 
-KResult FileDescription::chmod(mode_t mode)
+KResult OpenFileDescription::chmod(mode_t mode)
 {
     MutexLocker locker(m_lock);
     return m_file->chmod(*this, mode);
 }
 
-KResult FileDescription::chown(UserID uid, GroupID gid)
+KResult OpenFileDescription::chown(UserID uid, GroupID gid)
 {
     MutexLocker locker(m_lock);
     return m_file->chown(*this, uid, gid);
 }
 
-FileBlockerSet& FileDescription::blocker_set()
+FileBlockerSet& OpenFileDescription::blocker_set()
 {
     return m_file->blocker_set();
 }
 
-KResult FileDescription::apply_flock(Process const& process, Userspace<flock const*> lock)
+KResult OpenFileDescription::apply_flock(Process const& process, Userspace<flock const*> lock)
 {
     if (!m_inode)
         return EBADF;
@@ -443,7 +443,7 @@ KResult FileDescription::apply_flock(Process const& process, Userspace<flock con
     return m_inode->apply_flock(process, *this, lock);
 }
 
-KResult FileDescription::get_flock(Userspace<flock*> lock) const
+KResult OpenFileDescription::get_flock(Userspace<flock*> lock) const
 {
     if (!m_inode)
         return EBADF;

Kernel/FileSystem/OpenFileDescription.h

@@ -18,17 +18,17 @@
 
 namespace Kernel {
 
-class FileDescriptionData {
+class OpenFileDescriptionData {
 public:
-    virtual ~FileDescriptionData() = default;
+    virtual ~OpenFileDescriptionData() = default;
 };
 
-class FileDescription : public RefCounted<FileDescription> {
+class OpenFileDescription : public RefCounted<OpenFileDescription> {
-    MAKE_SLAB_ALLOCATED(FileDescription)
+    MAKE_SLAB_ALLOCATED(OpenFileDescription)
 public:
-    static KResultOr<NonnullRefPtr<FileDescription>> try_create(Custody&);
+    static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create(Custody&);
-    static KResultOr<NonnullRefPtr<FileDescription>> try_create(File&);
+    static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create(File&);
-    ~FileDescription();
+    ~OpenFileDescription();
 
     Thread::FileBlocker::BlockFlags should_unblock(Thread::FileBlocker::BlockFlags) const;
 
@@ -116,7 +116,7 @@ public:
     FIFO::Direction fifo_direction() const { return m_fifo_direction; }
     void set_fifo_direction(Badge<FIFO>, FIFO::Direction direction) { m_fifo_direction = direction; }
 
-    OwnPtr<FileDescriptionData>& data() { return m_data; }
+    OwnPtr<OpenFileDescriptionData>& data() { return m_data; }
 
     void set_original_inode(Badge<VirtualFileSystem>, NonnullRefPtr<Inode>&& inode) { m_inode = move(inode); }
 
@@ -133,7 +133,7 @@ public:
 
 private:
     friend class VirtualFileSystem;
-    explicit FileDescription(File&);
+    explicit OpenFileDescription(File&);
 
     KResult attach();
 
@@ -148,7 +148,7 @@ private:
 
     off_t m_current_offset { 0 };
 
-    OwnPtr<FileDescriptionData> m_data;
+    OwnPtr<OpenFileDescriptionData> m_data;
 
     u32 m_file_flags { 0 };
 
@@ -160,7 +160,7 @@ private:
     bool m_direct : 1 { false };
     FIFO::Direction m_fifo_direction { FIFO::Direction::Neither };
 
-    Mutex m_lock { "FileDescription" };
+    Mutex m_lock { "OpenFileDescription" };
 };
 
 }

Kernel/FileSystem/Plan9FileSystem.cpp

@@ -9,12 +9,12 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<Plan9FS>> Plan9FS::try_create(FileDescription& file_description)
+KResultOr<NonnullRefPtr<Plan9FS>> Plan9FS::try_create(OpenFileDescription& file_description)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) Plan9FS(file_description));
 }
 
-Plan9FS::Plan9FS(FileDescription& file_description)
+Plan9FS::Plan9FS(OpenFileDescription& file_description)
     : FileBackedFileSystem(file_description)
     , m_completion_blocker(*this)
 {
@@ -720,7 +720,7 @@ KResult Plan9FSInode::ensure_open_for_mode(int mode)
     }
 }
 
-KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     TRY(const_cast<Plan9FSInode&>(*this).ensure_open_for_mode(O_RDONLY));
 
@@ -752,7 +752,7 @@ KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKern
     return nread;
 }
 
-KResultOr<size_t> Plan9FSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& data, FileDescription*)
+KResultOr<size_t> Plan9FSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& data, OpenFileDescription*)
 {
     TRY(ensure_open_for_mode(O_WRONLY));
     size = fs().adjust_buffer_size(size);

Kernel/FileSystem/Plan9FileSystem.h

@@ -20,7 +20,7 @@ class Plan9FS final : public FileBackedFileSystem {
 
 public:
     virtual ~Plan9FS() override;
-    static KResultOr<NonnullRefPtr<Plan9FS>> try_create(FileDescription&);
+    static KResultOr<NonnullRefPtr<Plan9FS>> try_create(OpenFileDescription&);
 
     virtual KResult initialize() override;
 
@@ -46,7 +46,7 @@ public:
     class Message;
 
 private:
-    Plan9FS(FileDescription&);
+    Plan9FS(OpenFileDescription&);
 
     class Blocker;
 
@@ -156,8 +156,8 @@ public:
     // ^Inode
     virtual InodeMetadata metadata() const override;
     virtual void flush_metadata() override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;

Kernel/FileSystem/ProcFS.cpp

@@ -9,7 +9,7 @@
 #include <AK/Singleton.h>
 #include <Kernel/Debug.h>
 #include <Kernel/FileSystem/Custody.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/ProcFS.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/Heap/kmalloc.h>
@@ -115,7 +115,7 @@ ProcFSGlobalInode::ProcFSGlobalInode(const ProcFS& fs, const ProcFSExposedCompon
 {
 }
 
-void ProcFSGlobalInode::did_seek(FileDescription& description, off_t new_offset)
+void ProcFSGlobalInode::did_seek(OpenFileDescription& description, off_t new_offset)
 {
     if (new_offset != 0)
         return;
@@ -126,12 +126,12 @@ void ProcFSGlobalInode::did_seek(FileDescription& description, off_t new_offset)
     }
 }
 
-KResult ProcFSGlobalInode::attach(FileDescription& description)
+KResult ProcFSGlobalInode::attach(OpenFileDescription& description)
 {
     return m_associated_component->refresh_data(description);
 }
 
-KResultOr<size_t> ProcFSGlobalInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* fd) const
+KResultOr<size_t> ProcFSGlobalInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
 {
     return m_associated_component->read_bytes(offset, count, buffer, fd);
 }
@@ -164,7 +164,7 @@ InodeMetadata ProcFSGlobalInode::metadata() const
     return metadata;
 }
 
-KResultOr<size_t> ProcFSGlobalInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, FileDescription* fd)
+KResultOr<size_t> ProcFSGlobalInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* fd)
 {
     return m_associated_component->write_bytes(offset, count, buffer, fd);
 }
@@ -236,7 +236,7 @@ ProcFSProcessAssociatedInode::ProcFSProcessAssociatedInode(const ProcFS& fs, Pro
 {
 }
 
-KResultOr<size_t> ProcFSProcessAssociatedInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*)
+KResultOr<size_t> ProcFSProcessAssociatedInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     VERIFY_NOT_REACHED();
 }
@@ -251,7 +251,7 @@ ProcFSProcessDirectoryInode::ProcFSProcessDirectoryInode(const ProcFS& procfs, P
 {
 }
 
-KResult ProcFSProcessDirectoryInode::attach(FileDescription&)
+KResult ProcFSProcessDirectoryInode::attach(OpenFileDescription&)
 {
     return KSuccess;
 }
@@ -274,7 +274,7 @@ InodeMetadata ProcFSProcessDirectoryInode::metadata() const
     return metadata;
 }
 
-KResultOr<size_t> ProcFSProcessDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const
+KResultOr<size_t> ProcFSProcessDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
@@ -295,7 +295,7 @@ KResultOr<NonnullRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView n
     if (!process)
         return ESRCH;
     if (name == "fd"sv)
-        return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::FileDescriptions, associated_pid()));
+        return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions, associated_pid()));
     if (name == "stacks"sv)
         return TRY(ProcFSProcessSubDirectoryInode::try_create(procfs(), SegmentedProcFSIndex::ProcessSubDirectory::Stacks, associated_pid()));
     if (name == "unveil"sv)
@@ -303,7 +303,7 @@ KResultOr<NonnullRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView n
     if (name == "pledge"sv)
         return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::Pledge, associated_pid()));
     if (name == "fds"sv)
-        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::FileDescriptions, associated_pid()));
+        return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions, associated_pid()));
     if (name == "exe"sv)
         return TRY(ProcFSProcessPropertyInode::try_create_for_pid_property(procfs(), SegmentedProcFSIndex::MainProcessProperty::BinaryLink, associated_pid()));
     if (name == "cwd"sv)
@@ -326,17 +326,17 @@ ProcFSProcessSubDirectoryInode::ProcFSProcessSubDirectoryInode(const ProcFS& pro
 {
 }
 
-KResultOr<size_t> ProcFSProcessSubDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const
+KResultOr<size_t> ProcFSProcessSubDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult ProcFSProcessSubDirectoryInode::attach(FileDescription&)
+KResult ProcFSProcessSubDirectoryInode::attach(OpenFileDescription&)
 {
     return KSuccess;
 }
 
-void ProcFSProcessSubDirectoryInode::did_seek(FileDescription&, off_t)
+void ProcFSProcessSubDirectoryInode::did_seek(OpenFileDescription&, off_t)
 {
     VERIFY_NOT_REACHED();
 }
@@ -366,7 +366,7 @@ KResult ProcFSProcessSubDirectoryInode::traverse_as_directory(Function<bool(File
     if (!process)
         return EINVAL;
     switch (m_sub_directory_type) {
-    case SegmentedProcFSIndex::ProcessSubDirectory::FileDescriptions:
+    case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
         return process->traverse_file_descriptions_directory(procfs().fsid(), move(callback));
     case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
         return process->traverse_stacks_directory(procfs().fsid(), move(callback));
@@ -383,7 +383,7 @@ KResultOr<NonnullRefPtr<Inode>> ProcFSProcessSubDirectoryInode::lookup(StringVie
     if (!process)
         return ESRCH;
     switch (m_sub_directory_type) {
-    case SegmentedProcFSIndex::ProcessSubDirectory::FileDescriptions:
+    case SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions:
         return process->lookup_file_descriptions_directory(procfs(), name);
     case SegmentedProcFSIndex::ProcessSubDirectory::Stacks:
         return process->lookup_stacks_directory(procfs(), name);
@@ -414,7 +414,7 @@ ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(const ProcFS& procfs, Seg
 
 ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(const ProcFS& procfs, unsigned file_description_index, ProcessID pid)
     : ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_file_description(pid, file_description_index))
-    , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::FileDescriptions)
+    , m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
 {
     m_possible_data.property_index = file_description_index;
 }
@@ -426,11 +426,11 @@ ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(const ProcFS& procfs, Thr
     m_possible_data.property_index = thread_stack_index.value();
 }
 
-KResult ProcFSProcessPropertyInode::attach(FileDescription& description)
+KResult ProcFSProcessPropertyInode::attach(OpenFileDescription& description)
 {
     return refresh_data(description);
 }
-void ProcFSProcessPropertyInode::did_seek(FileDescription& description, off_t offset)
+void ProcFSProcessPropertyInode::did_seek(OpenFileDescription& description, off_t offset)
 {
     if (offset != 0)
         return;
@@ -439,7 +439,7 @@ void ProcFSProcessPropertyInode::did_seek(FileDescription& description, off_t of
 
 static mode_t determine_procfs_process_inode_mode(SegmentedProcFSIndex::ProcessSubDirectory parent_sub_directory_type, SegmentedProcFSIndex::MainProcessProperty main_property)
 {
-    if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::FileDescriptions)
+    if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
         return S_IFLNK | 0400;
     if (parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
         return S_IFREG | 0400;
@@ -472,7 +472,7 @@ KResult ProcFSProcessPropertyInode::traverse_as_directory(Function<bool(FileSyst
 {
     VERIFY_NOT_REACHED();
 }
-KResultOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
+KResultOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     dbgln_if(PROCFS_DEBUG, "ProcFS ProcessInformation: read_bytes offset: {} count: {}", offset, count);
 
@@ -526,7 +526,7 @@ static KResult build_from_cached_data(KBufferBuilder& builder, ProcFSInodeData&
 KResult ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBufferBuilder& builder) const
 {
     // FIXME: Verify process is already ref-counted
-    if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::FileDescriptions) {
+    if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions) {
         TRY(process.procfs_get_file_description_link(m_possible_data.property_index, builder));
         return KSuccess;
     }
@@ -541,7 +541,7 @@ KResult ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBuffe
         return process.procfs_get_unveil_stats(builder);
     case SegmentedProcFSIndex::MainProcessProperty::Pledge:
         return process.procfs_get_pledge_stats(builder);
-    case SegmentedProcFSIndex::MainProcessProperty::FileDescriptions:
+    case SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions:
         return process.procfs_get_fds_stats(builder);
     case SegmentedProcFSIndex::MainProcessProperty::BinaryLink:
         return process.procfs_get_binary_link(builder);
@@ -556,7 +556,7 @@ KResult ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBuffe
     }
 }
 
-KResult ProcFSProcessPropertyInode::refresh_data(FileDescription& description)
+KResult ProcFSProcessPropertyInode::refresh_data(OpenFileDescription& description)
 {
     // For process-specific inodes, hold the process's ptrace lock across refresh
     // and refuse to load data if the process is not dumpable.

Kernel/FileSystem/ProcFS.h

@@ -54,8 +54,8 @@ protected:
     ProcFS const& procfs() const { return static_cast<ProcFS const&>(Inode::fs()); }
 
     // ^Inode
-    virtual KResult attach(FileDescription& description) = 0;
+    virtual KResult attach(OpenFileDescription& description) = 0;
-    virtual void did_seek(FileDescription&, off_t) = 0;
+    virtual void did_seek(OpenFileDescription&, off_t) = 0;
     virtual void flush_metadata() override final;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override final;
     virtual KResult add_child(Inode&, const StringView& name, mode_t) override final;
@@ -77,10 +77,10 @@ protected:
     ProcFSGlobalInode(const ProcFS&, const ProcFSExposedComponent&);
 
     // ^Inode
-    virtual KResult attach(FileDescription& description) override final;
+    virtual KResult attach(OpenFileDescription& description) override final;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override final;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override final;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
-    virtual void did_seek(FileDescription&, off_t) override final;
+    virtual void did_seek(OpenFileDescription&, off_t) override final;
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView) override;
@@ -122,7 +122,7 @@ protected:
     ProcessID associated_pid() const { return m_pid; }
 
     // ^Inode
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override final;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
 
 private:
     const ProcessID m_pid;
@@ -137,11 +137,11 @@ public:
 private:
     ProcFSProcessDirectoryInode(const ProcFS&, ProcessID);
     // ^Inode
-    virtual KResult attach(FileDescription& description) override;
+    virtual KResult attach(OpenFileDescription& description) override;
-    virtual void did_seek(FileDescription&, off_t) override { }
+    virtual void did_seek(OpenFileDescription&, off_t) override { }
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override final;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
 };
 
@@ -154,11 +154,11 @@ public:
 private:
     ProcFSProcessSubDirectoryInode(const ProcFS&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
     // ^Inode
-    virtual KResult attach(FileDescription& description) override;
+    virtual KResult attach(OpenFileDescription& description) override;
-    virtual void did_seek(FileDescription&, off_t) override;
+    virtual void did_seek(OpenFileDescription&, off_t) override;
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override final;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
 
     const SegmentedProcFSIndex::ProcessSubDirectory m_sub_directory_type;
@@ -177,14 +177,14 @@ private:
     ProcFSProcessPropertyInode(const ProcFS&, ThreadID, ProcessID);
     ProcFSProcessPropertyInode(const ProcFS&, unsigned, ProcessID);
     // ^Inode
-    virtual KResult attach(FileDescription& description) override;
+    virtual KResult attach(OpenFileDescription& description) override;
-    virtual void did_seek(FileDescription&, off_t) override;
+    virtual void did_seek(OpenFileDescription&, off_t) override;
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override final;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override final;
 
-    KResult refresh_data(FileDescription& description);
+    KResult refresh_data(OpenFileDescription& description);
     KResult try_to_acquire_data(Process& process, KBufferBuilder& builder) const;
 
     const SegmentedProcFSIndex::ProcessSubDirectory m_parent_sub_directory_type;

Kernel/FileSystem/SysFS.cpp

@@ -96,7 +96,7 @@ SysFSInode::SysFSInode(SysFS const& fs, SysFSComponent const& component)
 {
 }
 
-void SysFSInode::did_seek(FileDescription& description, off_t new_offset)
+void SysFSInode::did_seek(OpenFileDescription& description, off_t new_offset)
 {
     if (new_offset != 0)
         return;
@@ -107,12 +107,12 @@ void SysFSInode::did_seek(FileDescription& description, off_t new_offset)
     }
 }
 
-KResult SysFSInode::attach(FileDescription& description)
+KResult SysFSInode::attach(OpenFileDescription& description)
 {
     return m_associated_component->refresh_data(description);
 }
 
-KResultOr<size_t> SysFSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* fd) const
+KResultOr<size_t> SysFSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
 {
     return m_associated_component->read_bytes(offset, count, buffer, fd);
 }
@@ -144,7 +144,7 @@ void SysFSInode::flush_metadata()
 {
 }
 
-KResultOr<size_t> SysFSInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, FileDescription* fd)
+KResultOr<size_t> SysFSInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* fd)
 {
     return m_associated_component->write_bytes(offset, count, buffer, fd);
 }

Kernel/FileSystem/SysFS.h

@@ -83,12 +83,12 @@ public:
 
 protected:
     SysFSInode(SysFS const&, SysFSComponent const&);
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     virtual void flush_metadata() override;
     virtual InodeMetadata metadata() const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) override;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
     virtual KResult add_child(Inode&, StringView const& name, mode_t) override;
     virtual KResult remove_child(StringView const& name) override;
@@ -96,8 +96,8 @@ protected:
     virtual KResult chown(UserID, GroupID) override;
     virtual KResult truncate(u64) override;
 
-    virtual KResult attach(FileDescription& description) override final;
+    virtual KResult attach(OpenFileDescription& description) override final;
-    virtual void did_seek(FileDescription&, off_t) override final;
+    virtual void did_seek(OpenFileDescription&, off_t) override final;
 
     NonnullRefPtr<SysFSComponent> m_associated_component;
 };

Kernel/FileSystem/SysFSComponent.h

@@ -13,24 +13,24 @@
 #include <AK/Types.h>
 #include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/File.h>
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Forward.h>
 
 namespace Kernel {
 
-struct SysFSInodeData : public FileDescriptionData {
+struct SysFSInodeData : public OpenFileDescriptionData {
     OwnPtr<KBuffer> buffer;
 };
 
 class SysFSComponent : public RefCounted<SysFSComponent> {
 public:
     virtual StringView name() const { return m_name->view(); }
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const { VERIFY_NOT_REACHED(); }
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const { VERIFY_NOT_REACHED(); }
     virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const { VERIFY_NOT_REACHED(); }
     virtual RefPtr<SysFSComponent> lookup(StringView) { VERIFY_NOT_REACHED(); };
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, FileDescription*) { return EROFS; }
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) { return EROFS; }
-    virtual KResult refresh_data(FileDescription&) const { return KSuccess; }
+    virtual KResult refresh_data(OpenFileDescription&) const { return KSuccess; }
 
     virtual KResultOr<NonnullRefPtr<SysFSInode>> to_inode(SysFS const&) const;
 

Kernel/FileSystem/TmpFS.cpp

@@ -123,7 +123,7 @@ KResult TmpFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEnt
     return KSuccess;
 }
 
-KResultOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     MutexLocker locker(m_inode_lock, Mutex::Mode::Shared);
     VERIFY(!is_directory());
@@ -142,7 +142,7 @@ KResultOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernel
     return size;
 }
 
-KResultOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& buffer, FileDescription*)
+KResultOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& buffer, OpenFileDescription*)
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(!is_directory());

Kernel/FileSystem/TmpFS.h

@@ -52,12 +52,12 @@ public:
     const TmpFS& fs() const { return static_cast<const TmpFS&>(Inode::fs()); }
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override;
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
     virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     virtual void flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override;
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
     virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
     virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
     virtual KResult remove_child(const StringView& name) override;

Kernel/FileSystem/VirtualFileSystem.cpp

@@ -11,8 +11,8 @@
 #include <Kernel/Devices/BlockDevice.h>
 #include <Kernel/FileSystem/Custody.h>
 #include <Kernel/FileSystem/FileBackedFileSystem.h>
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/KLexicalPath.h>
 #include <Kernel/KSyms.h>
@@ -203,7 +203,7 @@ KResultOr<InodeMetadata> VirtualFileSystem::lookup_metadata(StringView path, Cus
     return custody->inode().metadata();
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> VirtualFileSystem::open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> owner)
+KResultOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> owner)
 {
     if ((options & O_CREAT) && (options & O_DIRECTORY))
         return EINVAL;
@@ -288,7 +288,7 @@ KResultOr<NonnullRefPtr<FileDescription>> VirtualFileSystem::open(StringView pat
         TRY(inode.truncate(0));
         TRY(inode.set_mtime(kgettimeofday().to_truncated_seconds()));
     }
-    auto description = TRY(FileDescription::try_create(custody));
+    auto description = TRY(OpenFileDescription::try_create(custody));
     description->set_rw_mode(options);
     description->set_file_flags(options);
     return description;
@@ -319,7 +319,7 @@ KResult VirtualFileSystem::mknod(StringView path, mode_t mode, dev_t dev, Custod
     return parent_inode.create_child(basename, mode, dev, current_process.euid(), current_process.egid()).result();
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> VirtualFileSystem::create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> owner)
+KResultOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> owner)
 {
     auto basename = KLexicalPath::basename(path);
     auto parent_path = TRY(parent_custody.try_serialize_absolute_path());
@@ -345,7 +345,7 @@ KResultOr<NonnullRefPtr<FileDescription>> VirtualFileSystem::create(StringView p
     auto inode = TRY(parent_inode.create_child(basename, mode, 0, uid, gid));
     auto custody = TRY(Custody::try_create(&parent_custody, basename, inode, parent_custody.mount_flags()));
 
-    auto description = TRY(FileDescription::try_create(move(custody)));
+    auto description = TRY(OpenFileDescription::try_create(move(custody)));
     description->set_rw_mode(options);
     description->set_file_flags(options);
     return description;

Kernel/FileSystem/VirtualFileSystem.h

@@ -48,8 +48,8 @@ public:
     KResult remount(Custody& mount_point, int new_flags);
     KResult unmount(Inode& guest_inode);
 
-    KResultOr<NonnullRefPtr<FileDescription>> open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> = {});
+    KResultOr<NonnullRefPtr<OpenFileDescription>> open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> = {});
-    KResultOr<NonnullRefPtr<FileDescription>> create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> = {});
+    KResultOr<NonnullRefPtr<OpenFileDescription>> create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> = {});
     KResult mkdir(StringView path, mode_t mode, Custody& base);
     KResult link(StringView old_path, StringView new_path, Custody& base);
     KResult unlink(StringView path, Custody& base);
@@ -77,7 +77,7 @@ public:
     KResultOr<NonnullRefPtr<Custody>> resolve_path_without_veil(StringView path, Custody& base, RefPtr<Custody>* out_parent = nullptr, int options = 0, int symlink_recursion_level = 0);
 
 private:
-    friend class FileDescription;
+    friend class OpenFileDescription;
 
     UnveilNode const& find_matching_unveiled_path(StringView path);
     KResult validate_path_against_process_veil(Custody const& path, int options);

Kernel/Forward.h

@@ -24,7 +24,7 @@ class Device;
 class DiskCache;
 class DoubleBuffer;
 class File;
-class FileDescription;
+class OpenFileDescription;
 class FileSystem;
 class FutexQueue;
 class IPv4Socket;

Kernel/GlobalProcessExposed.cpp

@@ -15,7 +15,7 @@
 #include <Kernel/Devices/HID/HIDManagement.h>
 #include <Kernel/FileSystem/Custody.h>
 #include <Kernel/FileSystem/FileBackedFileSystem.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Heap/kmalloc.h>
 #include <Kernel/Interrupts/GenericInterruptHandler.h>
 #include <Kernel/Interrupts/InterruptManagement.h>

Kernel/Graphics/FramebufferDevice.cpp

@@ -25,7 +25,7 @@ NonnullRefPtr<FramebufferDevice> FramebufferDevice::create(const GraphicsDevice&
     return adopt_ref(*new FramebufferDevice(adapter, output_port_index, paddr, width, height, pitch));
 }
 
-KResultOr<Memory::Region*> FramebufferDevice::mmap(Process& process, FileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+KResultOr<Memory::Region*> FramebufferDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     SpinlockLocker lock(m_activation_lock);
     REQUIRE_PROMISE(video);
@@ -123,7 +123,7 @@ size_t FramebufferDevice::framebuffer_size_in_bytes() const
     return m_framebuffer_pitch * m_framebuffer_height;
 }
 
-KResult FramebufferDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> arg)
+KResult FramebufferDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     REQUIRE_PROMISE(video);
     switch (request) {

Kernel/Graphics/FramebufferDevice.h

@@ -22,8 +22,8 @@ class FramebufferDevice : public BlockDevice {
 public:
     static NonnullRefPtr<FramebufferDevice> create(const GraphicsDevice&, size_t, PhysicalAddress, size_t, size_t, size_t);
 
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
-    virtual KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
 
     // ^Device
     virtual mode_t required_mode() const override { return 0660; }
@@ -40,11 +40,11 @@ private:
     // ^File
     virtual StringView class_name() const override { return "FramebufferDevice"; }
 
-    virtual bool can_read(const FileDescription&, size_t) const override final { return true; }
+    virtual bool can_read(const OpenFileDescription&, size_t) const override final { return true; }
-    virtual bool can_write(const FileDescription&, size_t) const override final { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override final { return true; }
     virtual void start_request(AsyncBlockDeviceRequest& request) override final { request.complete(AsyncDeviceRequest::Failure); }
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
 
     FramebufferDevice(const GraphicsDevice&, size_t, PhysicalAddress, size_t, size_t, size_t);
 

Kernel/Graphics/VirtIOGPU/FrameBufferDevice.cpp

@@ -148,7 +148,7 @@ void FrameBufferDevice::set_buffer(int buffer_index)
     buffer.dirty_rect = {};
 }
 
-KResult FrameBufferDevice::ioctl(FileDescription&, unsigned request, Userspace<void*> arg)
+KResult FrameBufferDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     REQUIRE_PROMISE(video);
     switch (request) {
@@ -237,7 +237,7 @@ KResult FrameBufferDevice::ioctl(FileDescription&, unsigned request, Userspace<v
     };
 }
 
-KResultOr<Memory::Region*> FrameBufferDevice::mmap(Process& process, FileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+KResultOr<Memory::Region*> FrameBufferDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     REQUIRE_PROMISE(video);
     if (!shared)

Kernel/Graphics/VirtIOGPU/FrameBufferDevice.h

@@ -60,12 +60,12 @@ private:
     void create_buffer(Buffer&, size_t, size_t);
     void set_buffer(int);
 
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
-    virtual KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
-    virtual bool can_read(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
-    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; };
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; };
     virtual void start_request(AsyncBlockDeviceRequest& request) override { request.complete(AsyncDeviceRequest::Failure); }
 
     virtual mode_t required_mode() const override { return 0666; }

Kernel/KSyms.cpp

@@ -6,7 +6,7 @@
 
 #include <AK/TemporaryChange.h>
 #include <Kernel/Arch/x86/SmapDisabler.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/KSyms.h>
 #include <Kernel/Process.h>
 #include <Kernel/Scheduler.h>

Kernel/Net/IPv4Socket.cpp

@@ -7,7 +7,7 @@
 #include <AK/Singleton.h>
 #include <AK/StringBuilder.h>
 #include <Kernel/Debug.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Net/ARP.h>
 #include <Kernel/Net/ICMP.h>
 #include <Kernel/Net/IPv4.h>
@@ -28,7 +28,7 @@ namespace Kernel {
 
 static Singleton<MutexProtected<IPv4Socket::List>> s_all_sockets;
 
-using BlockFlags = Thread::FileDescriptionBlocker::BlockFlags;
+using BlockFlags = Thread::OpenFileDescriptionBlocker::BlockFlags;
 
 MutexProtected<IPv4Socket::List>& IPv4Socket::all_sockets()
 {
@@ -141,7 +141,7 @@ KResult IPv4Socket::listen(size_t backlog)
     return protocol_listen(result.did_allocate);
 }
 
-KResult IPv4Socket::connect(FileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock should_block)
+KResult IPv4Socket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock should_block)
 {
     if (address_size != sizeof(sockaddr_in))
         return set_so_error(EINVAL);
@@ -166,7 +166,7 @@ KResult IPv4Socket::connect(FileDescription& description, Userspace<const sockad
     return protocol_connect(description, should_block);
 }
 
-bool IPv4Socket::can_read(const FileDescription&, size_t) const
+bool IPv4Socket::can_read(const OpenFileDescription&, size_t) const
 {
     if (m_role == Role::Listener)
         return can_accept();
@@ -175,7 +175,7 @@ bool IPv4Socket::can_read(const FileDescription&, size_t) const
     return m_can_read;
 }
 
-bool IPv4Socket::can_write(const FileDescription&, size_t) const
+bool IPv4Socket::can_write(const OpenFileDescription&, size_t) const
 {
     return true;
 }
@@ -192,7 +192,7 @@ PortAllocationResult IPv4Socket::allocate_local_port_if_needed()
     return { m_local_port, true };
 }
 
-KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
+KResultOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
 {
     MutexLocker locker(mutex());
 
@@ -251,7 +251,7 @@ KResultOr<size_t> IPv4Socket::sendto(FileDescription&, const UserOrKernelBuffer&
     return nsent_or_error;
 }
 
-KResultOr<size_t> IPv4Socket::receive_byte_buffered(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>)
+KResultOr<size_t> IPv4Socket::receive_byte_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>)
 {
     MutexLocker locker(mutex());
     if (m_receive_buffer->is_empty()) {
@@ -287,7 +287,7 @@ KResultOr<size_t> IPv4Socket::receive_byte_buffered(FileDescription& description
     return nreceived_or_error;
 }
 
-KResultOr<size_t> IPv4Socket::receive_packet_buffered(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Time& packet_timestamp)
+KResultOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Time& packet_timestamp)
 {
     MutexLocker locker(mutex());
     ReceivedPacket packet;
@@ -379,7 +379,7 @@ KResultOr<size_t> IPv4Socket::receive_packet_buffered(FileDescription& descripti
     return protocol_receive(ReadonlyBytes { packet.data.value().data(), packet.data.value().size() }, buffer, buffer_length, flags);
 }
 
-KResultOr<size_t> IPv4Socket::recvfrom(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, Time& packet_timestamp)
+KResultOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, Time& packet_timestamp)
 {
     if (user_addr_length) {
         socklen_t addr_length;
@@ -450,7 +450,7 @@ bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port,
     return true;
 }
 
-String IPv4Socket::absolute_path(const FileDescription&) const
+String IPv4Socket::absolute_path(const OpenFileDescription&) const
 {
     if (m_role == Role::None)
         return "socket";
@@ -536,7 +536,7 @@ KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> use
     }
 }
 
-KResult IPv4Socket::getsockopt(FileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
+KResult IPv4Socket::getsockopt(OpenFileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
 {
     if (level != IPPROTO_IP)
         return Socket::getsockopt(description, level, option, value, value_size);
@@ -563,7 +563,7 @@ KResult IPv4Socket::getsockopt(FileDescription& description, int level, int opti
     }
 }
 
-KResult IPv4Socket::ioctl(FileDescription&, unsigned request, Userspace<void*> arg)
+KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     REQUIRE_PROMISE(inet);
 

Kernel/Net/IPv4Socket.h

@@ -33,18 +33,18 @@ public:
 
     virtual KResult close() override;
     virtual KResult bind(Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResult connect(FileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
+    virtual KResult connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
     virtual KResult listen(size_t) override;
     virtual void get_local_address(sockaddr*, socklen_t*) override;
     virtual void get_peer_address(sockaddr*, socklen_t*) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> sendto(FileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
+    virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResultOr<size_t> recvfrom(FileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
+    virtual KResultOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
     virtual KResult setsockopt(int level, int option, Userspace<const void*>, socklen_t) override;
-    virtual KResult getsockopt(FileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
+    virtual KResult getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
 
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
 
     bool did_receive(const IPv4Address& peer_address, u16 peer_port, ReadonlyBytes, const Time&);
 
@@ -61,7 +61,7 @@ public:
 
     IPv4SocketTuple tuple() const { return IPv4SocketTuple(m_local_address, m_local_port, m_peer_address, m_peer_port); }
 
-    String absolute_path(const FileDescription& description) const override;
+    String absolute_path(const OpenFileDescription& description) const override;
 
     u8 ttl() const { return m_ttl; }
 
@@ -81,7 +81,7 @@ protected:
     virtual KResult protocol_listen([[maybe_unused]] bool did_allocate_port) { return KSuccess; }
     virtual KResultOr<size_t> protocol_receive(ReadonlyBytes /* raw_ipv4_packet */, UserOrKernelBuffer&, size_t, int) { return ENOTIMPL; }
     virtual KResultOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) { return ENOTIMPL; }
-    virtual KResult protocol_connect(FileDescription&, ShouldBlock) { return KSuccess; }
+    virtual KResult protocol_connect(OpenFileDescription&, ShouldBlock) { return KSuccess; }
     virtual KResultOr<u16> protocol_allocate_local_port() { return ENOPROTOOPT; }
     virtual bool protocol_is_disconnected() const { return false; }
 
@@ -95,8 +95,8 @@ protected:
 private:
     virtual bool is_ipv4() const override { return true; }
 
-    KResultOr<size_t> receive_byte_buffered(FileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>);
+    KResultOr<size_t> receive_byte_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>);
-    KResultOr<size_t> receive_packet_buffered(FileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&);
+    KResultOr<size_t> receive_packet_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&);
 
     void set_can_read(bool);
 

Kernel/Net/LocalSocket.cpp

@@ -7,7 +7,7 @@
 #include <AK/Singleton.h>
 #include <AK/StringBuilder.h>
 #include <Kernel/Debug.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/Locking/Mutex.h>
 #include <Kernel/Locking/MutexProtected.h>
@@ -51,7 +51,7 @@ KResultOr<NonnullRefPtr<LocalSocket>> LocalSocket::try_create(int type)
 KResultOr<SocketPair> LocalSocket::try_create_connected_pair(int type)
 {
     auto socket = TRY(LocalSocket::try_create(type));
-    auto description1 = TRY(FileDescription::try_create(*socket));
+    auto description1 = TRY(OpenFileDescription::try_create(*socket));
 
     TRY(socket->try_set_path("[socketpair]"sv));
 
@@ -60,7 +60,7 @@ KResultOr<SocketPair> LocalSocket::try_create_connected_pair(int type)
     socket->set_connect_side_role(Role::Connected);
     socket->set_role(Role::Accepted);
 
-    auto description2 = TRY(FileDescription::try_create(*socket));
+    auto description2 = TRY(OpenFileDescription::try_create(*socket));
 
     return SocketPair { move(description1), move(description2) };
 }
@@ -155,7 +155,7 @@ KResult LocalSocket::bind(Userspace<const sockaddr*> user_address, socklen_t add
     return KSuccess;
 }
 
-KResult LocalSocket::connect(FileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock)
+KResult LocalSocket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock)
 {
     VERIFY(!m_bound);
     if (address_size != sizeof(sockaddr_un))
@@ -212,7 +212,7 @@ KResult LocalSocket::connect(FileDescription& description, Userspace<const socka
         return KSuccess;
     }
 
-    auto unblock_flags = Thread::FileDescriptionBlocker::BlockFlags::None;
+    auto unblock_flags = Thread::OpenFileDescriptionBlocker::BlockFlags::None;
     if (Thread::current()->block<Thread::ConnectBlocker>({}, description, unblock_flags).was_interrupted()) {
         set_connect_side_role(Role::None);
         return set_so_error(EINTR);
@@ -220,7 +220,7 @@ KResult LocalSocket::connect(FileDescription& description, Userspace<const socka
 
     dbgln_if(LOCAL_SOCKET_DEBUG, "LocalSocket({}) connect({}) status is {}", this, *m_path, to_string(setup_state()));
 
-    if (!has_flag(unblock_flags, Thread::FileDescriptionBlocker::BlockFlags::Connect)) {
+    if (!has_flag(unblock_flags, Thread::OpenFileDescriptionBlocker::BlockFlags::Connect)) {
         set_connect_side_role(Role::None);
         return set_so_error(ECONNREFUSED);
     }
@@ -243,7 +243,7 @@ KResult LocalSocket::listen(size_t backlog)
     return KSuccess;
 }
 
-KResult LocalSocket::attach(FileDescription& description)
+KResult LocalSocket::attach(OpenFileDescription& description)
 {
     VERIFY(!m_accept_side_fd_open);
     if (m_connect_side_role == Role::None) {
@@ -258,7 +258,7 @@ KResult LocalSocket::attach(FileDescription& description)
     return KSuccess;
 }
 
-void LocalSocket::detach(FileDescription& description)
+void LocalSocket::detach(OpenFileDescription& description)
 {
     if (m_connect_side_fd == &description) {
         m_connect_side_fd = nullptr;
@@ -270,7 +270,7 @@ void LocalSocket::detach(FileDescription& description)
     evaluate_block_conditions();
 }
 
-bool LocalSocket::can_read(const FileDescription& description, size_t) const
+bool LocalSocket::can_read(const OpenFileDescription& description, size_t) const
 {
     auto role = this->role(description);
     if (role == Role::Listener)
@@ -282,7 +282,7 @@ bool LocalSocket::can_read(const FileDescription& description, size_t) const
     return false;
 }
 
-bool LocalSocket::has_attached_peer(const FileDescription& description) const
+bool LocalSocket::has_attached_peer(const OpenFileDescription& description) const
 {
     auto role = this->role(description);
     if (role == Role::Accepted)
@@ -292,7 +292,7 @@ bool LocalSocket::has_attached_peer(const FileDescription& description) const
     return false;
 }
 
-bool LocalSocket::can_write(const FileDescription& description, size_t) const
+bool LocalSocket::can_write(const OpenFileDescription& description, size_t) const
 {
     auto role = this->role(description);
     if (role == Role::Accepted)
@@ -302,7 +302,7 @@ bool LocalSocket::can_write(const FileDescription& description, size_t) const
     return false;
 }
 
-KResultOr<size_t> LocalSocket::sendto(FileDescription& description, const UserOrKernelBuffer& data, size_t data_size, int, Userspace<const sockaddr*>, socklen_t)
+KResultOr<size_t> LocalSocket::sendto(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size, int, Userspace<const sockaddr*>, socklen_t)
 {
     if (!has_attached_peer(description))
         return set_so_error(EPIPE);
@@ -315,7 +315,7 @@ KResultOr<size_t> LocalSocket::sendto(FileDescription& description, const UserOr
     return nwritten_or_error;
 }
 
-DoubleBuffer* LocalSocket::receive_buffer_for(FileDescription& description)
+DoubleBuffer* LocalSocket::receive_buffer_for(OpenFileDescription& description)
 {
     auto role = this->role(description);
     if (role == Role::Accepted)
@@ -325,7 +325,7 @@ DoubleBuffer* LocalSocket::receive_buffer_for(FileDescription& description)
     return nullptr;
 }
 
-DoubleBuffer* LocalSocket::send_buffer_for(FileDescription& description)
+DoubleBuffer* LocalSocket::send_buffer_for(OpenFileDescription& description)
 {
     auto role = this->role(description);
     if (role == Role::Connected)
@@ -335,7 +335,7 @@ DoubleBuffer* LocalSocket::send_buffer_for(FileDescription& description)
     return nullptr;
 }
 
-KResultOr<size_t> LocalSocket::recvfrom(FileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_size, int, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&)
+KResultOr<size_t> LocalSocket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_size, int, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&)
 {
     auto* socket_buffer = receive_buffer_for(description);
     if (!socket_buffer)
@@ -347,7 +347,7 @@ KResultOr<size_t> LocalSocket::recvfrom(FileDescription& description, UserOrKern
             return set_so_error(EAGAIN);
         }
     } else if (!can_read(description, 0)) {
-        auto unblock_flags = Thread::FileDescriptionBlocker::BlockFlags::None;
+        auto unblock_flags = Thread::OpenFileDescriptionBlocker::BlockFlags::None;
         if (Thread::current()->block<Thread::ReadBlocker>({}, description, unblock_flags).was_interrupted())
             return set_so_error(EINTR);
     }
@@ -367,7 +367,7 @@ StringView LocalSocket::socket_path() const
     return m_path->view();
 }
 
-String LocalSocket::absolute_path(const FileDescription& description) const
+String LocalSocket::absolute_path(const OpenFileDescription& description) const
 {
     StringBuilder builder;
     builder.append("socket:");
@@ -393,7 +393,7 @@ String LocalSocket::absolute_path(const FileDescription& description) const
     return builder.to_string();
 }
 
-KResult LocalSocket::getsockopt(FileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
+KResult LocalSocket::getsockopt(OpenFileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
 {
     if (level != SOL_SOCKET)
         return Socket::getsockopt(description, level, option, value, value_size);
@@ -432,7 +432,7 @@ KResult LocalSocket::getsockopt(FileDescription& description, int level, int opt
     }
 }
 
-KResult LocalSocket::ioctl(FileDescription& description, unsigned request, Userspace<void*> arg)
+KResult LocalSocket::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case FIONREAD: {
@@ -444,7 +444,7 @@ KResult LocalSocket::ioctl(FileDescription& description, unsigned request, Users
     return ENOTTY;
 }
 
-KResult LocalSocket::chmod(FileDescription&, mode_t mode)
+KResult LocalSocket::chmod(OpenFileDescription&, mode_t mode)
 {
     if (m_file)
         return m_file->chmod(mode);
@@ -453,7 +453,7 @@ KResult LocalSocket::chmod(FileDescription&, mode_t mode)
     return KSuccess;
 }
 
-KResult LocalSocket::chown(FileDescription&, UserID uid, GroupID gid)
+KResult LocalSocket::chown(OpenFileDescription&, UserID uid, GroupID gid)
 {
     if (m_file)
         return m_file->chown(uid, gid);
@@ -467,7 +467,7 @@ KResult LocalSocket::chown(FileDescription&, UserID uid, GroupID gid)
     return KSuccess;
 }
 
-NonnullRefPtrVector<FileDescription>& LocalSocket::recvfd_queue_for(const FileDescription& description)
+NonnullRefPtrVector<OpenFileDescription>& LocalSocket::recvfd_queue_for(const OpenFileDescription& description)
 {
     auto role = this->role(description);
     if (role == Role::Connected)
@@ -477,7 +477,7 @@ NonnullRefPtrVector<FileDescription>& LocalSocket::recvfd_queue_for(const FileDe
     VERIFY_NOT_REACHED();
 }
 
-NonnullRefPtrVector<FileDescription>& LocalSocket::sendfd_queue_for(const FileDescription& description)
+NonnullRefPtrVector<OpenFileDescription>& LocalSocket::sendfd_queue_for(const OpenFileDescription& description)
 {
     auto role = this->role(description);
     if (role == Role::Connected)
@@ -487,7 +487,7 @@ NonnullRefPtrVector<FileDescription>& LocalSocket::sendfd_queue_for(const FileDe
     VERIFY_NOT_REACHED();
 }
 
-KResult LocalSocket::sendfd(const FileDescription& socket_description, FileDescription& passing_description)
+KResult LocalSocket::sendfd(const OpenFileDescription& socket_description, OpenFileDescription& passing_description)
 {
     MutexLocker locker(mutex());
     auto role = this->role(socket_description);
@@ -502,7 +502,7 @@ KResult LocalSocket::sendfd(const FileDescription& socket_description, FileDescr
     return KSuccess;
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> LocalSocket::recvfd(const FileDescription& socket_description)
+KResultOr<NonnullRefPtr<OpenFileDescription>> LocalSocket::recvfd(const OpenFileDescription& socket_description)
 {
     MutexLocker locker(mutex());
     auto role = this->role(socket_description);

Kernel/Net/LocalSocket.h

@@ -12,11 +12,11 @@
 
 namespace Kernel {
 
-class FileDescription;
+class OpenFileDescription;
 
 struct SocketPair {
-    NonnullRefPtr<FileDescription> description0;
+    NonnullRefPtr<OpenFileDescription> description0;
-    NonnullRefPtr<FileDescription> description1;
+    NonnullRefPtr<OpenFileDescription> description1;
 };
 
 class LocalSocket final : public Socket {
@@ -26,40 +26,40 @@ public:
     static KResultOr<SocketPair> try_create_connected_pair(int type);
     virtual ~LocalSocket() override;
 
-    KResult sendfd(const FileDescription& socket_description, FileDescription& passing_description);
+    KResult sendfd(const OpenFileDescription& socket_description, OpenFileDescription& passing_description);
-    KResultOr<NonnullRefPtr<FileDescription>> recvfd(const FileDescription& socket_description);
+    KResultOr<NonnullRefPtr<OpenFileDescription>> recvfd(const OpenFileDescription& socket_description);
 
     static void for_each(Function<void(const LocalSocket&)>);
 
     StringView socket_path() const;
-    String absolute_path(const FileDescription& description) const override;
+    String absolute_path(const OpenFileDescription& description) const override;
 
     // ^Socket
     virtual KResult bind(Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResult connect(FileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
+    virtual KResult connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
     virtual KResult listen(size_t) override;
     virtual void get_local_address(sockaddr*, socklen_t*) override;
     virtual void get_peer_address(sockaddr*, socklen_t*) override;
-    virtual KResult attach(FileDescription&) override;
+    virtual KResult attach(OpenFileDescription&) override;
-    virtual void detach(FileDescription&) override;
+    virtual void detach(OpenFileDescription&) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> sendto(FileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
+    virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResultOr<size_t> recvfrom(FileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
+    virtual KResultOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
-    virtual KResult getsockopt(FileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
+    virtual KResult getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
-    virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
-    virtual KResult chown(FileDescription&, UserID, GroupID) override;
+    virtual KResult chown(OpenFileDescription&, UserID, GroupID) override;
-    virtual KResult chmod(FileDescription&, mode_t) override;
+    virtual KResult chmod(OpenFileDescription&, mode_t) override;
 
 private:
     explicit LocalSocket(int type, NonnullOwnPtr<DoubleBuffer> client_buffer, NonnullOwnPtr<DoubleBuffer> server_buffer);
     virtual StringView class_name() const override { return "LocalSocket"; }
     virtual bool is_local() const override { return true; }
-    bool has_attached_peer(const FileDescription&) const;
+    bool has_attached_peer(const OpenFileDescription&) const;
-    DoubleBuffer* receive_buffer_for(FileDescription&);
+    DoubleBuffer* receive_buffer_for(OpenFileDescription&);
-    DoubleBuffer* send_buffer_for(FileDescription&);
+    DoubleBuffer* send_buffer_for(OpenFileDescription&);
-    NonnullRefPtrVector<FileDescription>& sendfd_queue_for(const FileDescription&);
+    NonnullRefPtrVector<OpenFileDescription>& sendfd_queue_for(const OpenFileDescription&);
-    NonnullRefPtrVector<FileDescription>& recvfd_queue_for(const FileDescription&);
+    NonnullRefPtrVector<OpenFileDescription>& recvfd_queue_for(const OpenFileDescription&);
 
     void set_connect_side_role(Role connect_side_role, bool force_evaluate_block_conditions = false)
     {
@@ -72,7 +72,7 @@ private:
     KResult try_set_path(StringView);
 
     // An open socket file on the filesystem.
-    RefPtr<FileDescription> m_file;
+    RefPtr<OpenFileDescription> m_file;
 
     UserID m_prebind_uid { 0 };
     GroupID m_prebind_gid { 0 };
@@ -83,9 +83,9 @@ private:
     // an additional role for the connect side and differentiate
     // between them.
     Role m_connect_side_role { Role::None };
-    FileDescription* m_connect_side_fd { nullptr };
+    OpenFileDescription* m_connect_side_fd { nullptr };
 
-    virtual Role role(const FileDescription& description) const override
+    virtual Role role(const OpenFileDescription& description) const override
     {
         if (m_connect_side_fd == &description)
             return m_connect_side_role;
@@ -99,8 +99,8 @@ private:
     NonnullOwnPtr<DoubleBuffer> m_for_client;
     NonnullOwnPtr<DoubleBuffer> m_for_server;
 
-    NonnullRefPtrVector<FileDescription> m_fds_for_client;
+    NonnullRefPtrVector<OpenFileDescription> m_fds_for_client;
-    NonnullRefPtrVector<FileDescription> m_fds_for_server;
+    NonnullRefPtrVector<OpenFileDescription> m_fds_for_server;
 
     IntrusiveListNode<LocalSocket> m_list_node;
 

Kernel/Net/Socket.cpp

@@ -6,7 +6,7 @@
 
 #include <AK/StringView.h>
 #include <Kernel/Debug.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Net/IPv4Socket.h>
 #include <Kernel/Net/LocalSocket.h>
 #include <Kernel/Net/NetworkingManagement.h>
@@ -133,7 +133,7 @@ KResult Socket::setsockopt(int level, int option, Userspace<const void*> user_va
     }
 }
 
-KResult Socket::getsockopt(FileDescription&, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
+KResult Socket::getsockopt(OpenFileDescription&, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
 {
     socklen_t size;
     TRY(copy_from_user(&size, value_size.unsafe_userspace_ptr()));
@@ -199,7 +199,7 @@ KResult Socket::getsockopt(FileDescription&, int level, int option, Userspace<vo
     }
 }
 
-KResultOr<size_t> Socket::read(FileDescription& description, u64, UserOrKernelBuffer& buffer, size_t size)
+KResultOr<size_t> Socket::read(OpenFileDescription& description, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (is_shut_down_for_reading())
         return 0;
@@ -207,7 +207,7 @@ KResultOr<size_t> Socket::read(FileDescription& description, u64, UserOrKernelBu
     return recvfrom(description, buffer, size, 0, {}, 0, t);
 }
 
-KResultOr<size_t> Socket::write(FileDescription& description, u64, const UserOrKernelBuffer& data, size_t size)
+KResultOr<size_t> Socket::write(OpenFileDescription& description, u64, const UserOrKernelBuffer& data, size_t size)
 {
     if (is_shut_down_for_writing())
         return set_so_error(EPIPE);

Kernel/Net/Socket.h

@@ -23,7 +23,7 @@ enum class ShouldBlock {
     Yes = 1
 };
 
-class FileDescription;
+class OpenFileDescription;
 
 class Socket : public File {
 public:
@@ -68,7 +68,7 @@ public:
     SetupState setup_state() const { return m_setup_state; }
     void set_setup_state(SetupState setup_state);
 
-    virtual Role role(const FileDescription&) const { return m_role; }
+    virtual Role role(const OpenFileDescription&) const { return m_role; }
 
     bool is_connected() const { return m_connected; }
     void set_connected(bool);
@@ -79,17 +79,17 @@ public:
     KResult shutdown(int how);
 
     virtual KResult bind(Userspace<const sockaddr*>, socklen_t) = 0;
-    virtual KResult connect(FileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock) = 0;
+    virtual KResult connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock) = 0;
     virtual KResult listen(size_t) = 0;
     virtual void get_local_address(sockaddr*, socklen_t*) = 0;
     virtual void get_peer_address(sockaddr*, socklen_t*) = 0;
     virtual bool is_local() const { return false; }
     virtual bool is_ipv4() const { return false; }
-    virtual KResultOr<size_t> sendto(FileDescription&, const UserOrKernelBuffer&, size_t, int flags, Userspace<const sockaddr*>, socklen_t) = 0;
+    virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int flags, Userspace<const sockaddr*>, socklen_t) = 0;
-    virtual KResultOr<size_t> recvfrom(FileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) = 0;
+    virtual KResultOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) = 0;
 
     virtual KResult setsockopt(int level, int option, Userspace<const void*>, socklen_t);
-    virtual KResult getsockopt(FileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>);
+    virtual KResult getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>);
 
     ProcessID origin_pid() const { return m_origin.pid; }
     UserID origin_uid() const { return m_origin.uid; }
@@ -102,10 +102,10 @@ public:
     Mutex& mutex() { return m_mutex; }
 
     // ^File
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override final;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override final;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override final;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override final;
     virtual KResult stat(::stat&) const override;
-    virtual String absolute_path(const FileDescription&) const override = 0;
+    virtual String absolute_path(const OpenFileDescription&) const override = 0;
 
     bool has_receive_timeout() const { return m_receive_timeout != Time::zero(); }
     const Time& receive_timeout() const { return m_receive_timeout; }

Kernel/Net/TCPSocket.cpp

@@ -8,7 +8,7 @@
 #include <AK/Time.h>
 #include <Kernel/Debug.h>
 #include <Kernel/Devices/RandomDevice.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Locking/MutexProtected.h>
 #include <Kernel/Net/EthernetFrameHeader.h>
 #include <Kernel/Net/IPv4.h>
@@ -394,7 +394,7 @@ KResult TCPSocket::protocol_listen(bool did_allocate_port)
     return KSuccess;
 }
 
-KResult TCPSocket::protocol_connect(FileDescription& description, ShouldBlock should_block)
+KResult TCPSocket::protocol_connect(OpenFileDescription& description, ShouldBlock should_block)
 {
     MutexLocker locker(mutex());
 
@@ -597,7 +597,7 @@ void TCPSocket::retransmit_packets()
     });
 }
 
-bool TCPSocket::can_write(const FileDescription& file_description, size_t size) const
+bool TCPSocket::can_write(const OpenFileDescription& file_description, size_t size) const
 {
     if (!IPv4Socket::can_write(file_description, size))
         return false;

Kernel/Net/TCPSocket.h

@@ -157,7 +157,7 @@ public:
 
     virtual KResult close() override;
 
-    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual bool can_write(const OpenFileDescription&, size_t) const override;
 
     static NetworkOrdered<u16> compute_tcp_checksum(IPv4Address const& source, IPv4Address const& destination, TCPPacket const&, u16 payload_size);
 
@@ -172,7 +172,7 @@ private:
 
     virtual KResultOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
     virtual KResultOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
-    virtual KResult protocol_connect(FileDescription&, ShouldBlock) override;
+    virtual KResult protocol_connect(OpenFileDescription&, ShouldBlock) override;
     virtual KResultOr<u16> protocol_allocate_local_port() override;
     virtual bool protocol_is_disconnected() const override;
     virtual KResult protocol_bind() override;

Kernel/Net/UDPSocket.cpp

@@ -95,7 +95,7 @@ KResultOr<size_t> UDPSocket::protocol_send(const UserOrKernelBuffer& data, size_
     return data_length;
 }
 
-KResult UDPSocket::protocol_connect(FileDescription&, ShouldBlock)
+KResult UDPSocket::protocol_connect(OpenFileDescription&, ShouldBlock)
 {
     set_role(Role::Connected);
     set_connected(true);

Kernel/Net/UDPSocket.h

@@ -27,7 +27,7 @@ private:
 
     virtual KResultOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
     virtual KResultOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
-    virtual KResult protocol_connect(FileDescription&, ShouldBlock) override;
+    virtual KResult protocol_connect(OpenFileDescription&, ShouldBlock) override;
     virtual KResultOr<u16> protocol_allocate_local_port() override;
     virtual KResult protocol_bind() override;
 };

Kernel/Process.cpp

@@ -18,7 +18,7 @@
 #endif
 #include <Kernel/Devices/NullDevice.h>
 #include <Kernel/FileSystem/Custody.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/KBufferBuilder.h>
 #include <Kernel/KSyms.h>
@@ -415,7 +415,7 @@ RefPtr<Process> Process::from_pid(ProcessID pid)
     });
 }
 
-const Process::FileDescriptionAndFlags* Process::FileDescriptions::get_if_valid(size_t i) const
+const Process::OpenFileDescriptionAndFlags* Process::OpenFileDescriptions::get_if_valid(size_t i) const
 {
     SpinlockLocker lock(m_fds_lock);
     if (m_fds_metadatas.size() <= i)
@@ -426,7 +426,7 @@ const Process::FileDescriptionAndFlags* Process::FileDescriptions::get_if_valid(
 
     return nullptr;
 }
-Process::FileDescriptionAndFlags* Process::FileDescriptions::get_if_valid(size_t i)
+Process::OpenFileDescriptionAndFlags* Process::OpenFileDescriptions::get_if_valid(size_t i)
 {
     SpinlockLocker lock(m_fds_lock);
     if (m_fds_metadatas.size() <= i)
@@ -438,20 +438,20 @@ Process::FileDescriptionAndFlags* Process::FileDescriptions::get_if_valid(size_t
     return nullptr;
 }
 
-const Process::FileDescriptionAndFlags& Process::FileDescriptions::at(size_t i) const
+const Process::OpenFileDescriptionAndFlags& Process::OpenFileDescriptions::at(size_t i) const
 {
     SpinlockLocker lock(m_fds_lock);
     VERIFY(m_fds_metadatas[i].is_allocated());
     return m_fds_metadatas[i];
 }
-Process::FileDescriptionAndFlags& Process::FileDescriptions::at(size_t i)
+Process::OpenFileDescriptionAndFlags& Process::OpenFileDescriptions::at(size_t i)
 {
     SpinlockLocker lock(m_fds_lock);
     VERIFY(m_fds_metadatas[i].is_allocated());
     return m_fds_metadatas[i];
 }
 
-KResultOr<NonnullRefPtr<FileDescription>> Process::FileDescriptions::file_description(int fd) const
+KResultOr<NonnullRefPtr<OpenFileDescription>> Process::OpenFileDescriptions::file_description(int fd) const
 {
     SpinlockLocker lock(m_fds_lock);
     if (fd < 0)
@@ -464,7 +464,7 @@ KResultOr<NonnullRefPtr<FileDescription>> Process::FileDescriptions::file_descri
     return description.release_nonnull();
 }
 
-void Process::FileDescriptions::enumerate(Function<void(const FileDescriptionAndFlags&)> callback) const
+void Process::OpenFileDescriptions::enumerate(Function<void(const OpenFileDescriptionAndFlags&)> callback) const
 {
     SpinlockLocker lock(m_fds_lock);
     for (auto& file_description_metadata : m_fds_metadatas) {
@@ -472,7 +472,7 @@ void Process::FileDescriptions::enumerate(Function<void(const FileDescriptionAnd
     }
 }
 
-void Process::FileDescriptions::change_each(Function<void(FileDescriptionAndFlags&)> callback)
+void Process::OpenFileDescriptions::change_each(Function<void(OpenFileDescriptionAndFlags&)> callback)
 {
     SpinlockLocker lock(m_fds_lock);
     for (auto& file_description_metadata : m_fds_metadatas) {
@@ -480,7 +480,7 @@ void Process::FileDescriptions::change_each(Function<void(FileDescriptionAndFlag
     }
 }
 
-size_t Process::FileDescriptions::open_count() const
+size_t Process::OpenFileDescriptions::open_count() const
 {
     size_t count = 0;
     enumerate([&](auto& file_description_metadata) {
@@ -490,7 +490,7 @@ size_t Process::FileDescriptions::open_count() const
     return count;
 }
 
-KResultOr<Process::ScopedDescriptionAllocation> Process::FileDescriptions::allocate(int first_candidate_fd)
+KResultOr<Process::ScopedDescriptionAllocation> Process::OpenFileDescriptions::allocate(int first_candidate_fd)
 {
     SpinlockLocker lock(m_fds_lock);
     for (size_t i = first_candidate_fd; i < max_open(); ++i) {
@@ -764,14 +764,14 @@ RefPtr<Thread> Process::create_kernel_thread(void (*entry)(void*), void* entry_d
     return thread;
 }
 
-void Process::FileDescriptionAndFlags::clear()
+void Process::OpenFileDescriptionAndFlags::clear()
 {
     // FIXME: Verify Process::m_fds_lock is locked!
     m_description = nullptr;
     m_flags = 0;
 }
 
-void Process::FileDescriptionAndFlags::set(NonnullRefPtr<FileDescription>&& description, u32 flags)
+void Process::OpenFileDescriptionAndFlags::set(NonnullRefPtr<OpenFileDescription>&& description, u32 flags)
 {
     // FIXME: Verify Process::m_fds_lock is locked!
     m_description = move(description);

Kernel/Process.h

@@ -19,8 +19,8 @@
 #include <AK/Weakable.h>
 #include <Kernel/API/Syscall.h>
 #include <Kernel/AtomicEdgeAction.h>
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/InodeMetadata.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/FileSystem/UnveilNode.h>
 #include <Kernel/Forward.h>
 #include <Kernel/FutexQueue.h>
@@ -120,7 +120,7 @@ public:
 
     friend class Thread;
     friend class Coredump;
-    friend class ProcFSProcessFileDescriptions;
+    friend class ProcFSProcessOpenFileDescriptions;
 
     // Helper class to temporarily unprotect a process's protected data so you can write to it.
     class ProtectedDataMutationScope {
@@ -443,7 +443,7 @@ public:
 
     KResult exec(NonnullOwnPtr<KString> path, Vector<String> arguments, Vector<String> environment, int recusion_depth = 0);
 
-    KResultOr<LoadResult> load(NonnullRefPtr<FileDescription> main_program_description, RefPtr<FileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header);
+    KResultOr<LoadResult> load(NonnullRefPtr<OpenFileDescription> main_program_description, RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header);
 
     bool is_superuser() const { return euid() == 0; }
 
@@ -533,12 +533,12 @@ private:
     bool create_perf_events_buffer_if_needed();
     void delete_perf_events_buffer();
 
-    KResult do_exec(NonnullRefPtr<FileDescription> main_program_description, Vector<String> arguments, Vector<String> environment, RefPtr<FileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const ElfW(Ehdr) & main_program_header);
+    KResult do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, Vector<String> arguments, Vector<String> environment, RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const ElfW(Ehdr) & main_program_header);
-    KResultOr<FlatPtr> do_write(FileDescription&, const UserOrKernelBuffer&, size_t);
+    KResultOr<FlatPtr> do_write(OpenFileDescription&, const UserOrKernelBuffer&, size_t);
 
     KResultOr<FlatPtr> do_statvfs(StringView path, statvfs* buf);
 
-    KResultOr<RefPtr<FileDescription>> find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size);
+    KResultOr<RefPtr<OpenFileDescription>> find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size);
 
     KResult do_kill(Process&, int signal);
     KResult do_killpg(ProcessGroupID pgrp, int signal);
@@ -554,7 +554,7 @@ private:
 
     void clear_futex_queues_on_exec();
 
-    void setup_socket_fd(int fd, NonnullRefPtr<FileDescription> description, int type);
+    void setup_socket_fd(int fd, NonnullRefPtr<OpenFileDescription> description, int type);
 
 public:
     NonnullRefPtr<ProcessProcFSTraits> procfs_traits() const { return *m_procfs_traits; }
@@ -599,7 +599,7 @@ private:
     OwnPtr<ThreadTracer> m_tracer;
 
 public:
-    class FileDescriptionAndFlags {
+    class OpenFileDescriptionAndFlags {
     public:
         bool is_valid() const { return !m_description.is_null(); }
         bool is_allocated() const { return m_is_allocated; }
@@ -616,30 +616,30 @@ public:
             m_is_allocated = false;
         }
 
-        FileDescription* description() { return m_description; }
+        OpenFileDescription* description() { return m_description; }
-        const FileDescription* description() const { return m_description; }
+        const OpenFileDescription* description() const { return m_description; }
         u32 flags() const { return m_flags; }
         void set_flags(u32 flags) { m_flags = flags; }
 
         void clear();
-        void set(NonnullRefPtr<FileDescription>&&, u32 flags = 0);
+        void set(NonnullRefPtr<OpenFileDescription>&&, u32 flags = 0);
 
     private:
-        RefPtr<FileDescription> m_description;
+        RefPtr<OpenFileDescription> m_description;
         bool m_is_allocated { false };
         u32 m_flags { 0 };
     };
 
     class ScopedDescriptionAllocation;
-    class FileDescriptions {
+    class OpenFileDescriptions {
-        AK_MAKE_NONCOPYABLE(FileDescriptions);
+        AK_MAKE_NONCOPYABLE(OpenFileDescriptions);
         friend class Process;
 
     public:
-        ALWAYS_INLINE const FileDescriptionAndFlags& operator[](size_t i) const { return at(i); }
+        ALWAYS_INLINE const OpenFileDescriptionAndFlags& operator[](size_t i) const { return at(i); }
-        ALWAYS_INLINE FileDescriptionAndFlags& operator[](size_t i) { return at(i); }
+        ALWAYS_INLINE OpenFileDescriptionAndFlags& operator[](size_t i) { return at(i); }
 
-        KResult try_clone(const Kernel::Process::FileDescriptions& other)
+        KResult try_clone(const Kernel::Process::OpenFileDescriptions& other)
         {
             SpinlockLocker lock_other(other.m_fds_lock);
             if (!try_resize(other.m_fds_metadatas.size()))
@@ -651,14 +651,14 @@ public:
             return KSuccess;
         }
 
-        const FileDescriptionAndFlags& at(size_t i) const;
+        const OpenFileDescriptionAndFlags& at(size_t i) const;
-        FileDescriptionAndFlags& at(size_t i);
+        OpenFileDescriptionAndFlags& at(size_t i);
 
-        FileDescriptionAndFlags const* get_if_valid(size_t i) const;
+        OpenFileDescriptionAndFlags const* get_if_valid(size_t i) const;
-        FileDescriptionAndFlags* get_if_valid(size_t i);
+        OpenFileDescriptionAndFlags* get_if_valid(size_t i);
 
-        void enumerate(Function<void(const FileDescriptionAndFlags&)>) const;
+        void enumerate(Function<void(const OpenFileDescriptionAndFlags&)>) const;
-        void change_each(Function<void(FileDescriptionAndFlags&)>);
+        void change_each(Function<void(OpenFileDescriptionAndFlags&)>);
 
         KResultOr<ScopedDescriptionAllocation> allocate(int first_candidate_fd = 0);
         size_t open_count() const;
@@ -676,13 +676,13 @@ public:
             m_fds_metadatas.clear();
         }
 
-        KResultOr<NonnullRefPtr<FileDescription>> file_description(int fd) const;
+        KResultOr<NonnullRefPtr<OpenFileDescription>> file_description(int fd) const;
 
     private:
-        FileDescriptions() = default;
+        OpenFileDescriptions() = default;
         static constexpr size_t m_max_open_file_descriptors { FD_SETSIZE };
         mutable Spinlock m_fds_lock;
-        Vector<FileDescriptionAndFlags> m_fds_metadatas;
+        Vector<OpenFileDescriptionAndFlags> m_fds_metadatas;
     };
 
     class ScopedDescriptionAllocation {
@@ -690,7 +690,7 @@ public:
 
     public:
         ScopedDescriptionAllocation() = default;
-        ScopedDescriptionAllocation(int tracked_fd, FileDescriptionAndFlags* description)
+        ScopedDescriptionAllocation(int tracked_fd, OpenFileDescriptionAndFlags* description)
             : fd(tracked_fd)
             , m_description(description)
         {
@@ -713,7 +713,7 @@ public:
         const int fd { -1 };
 
     private:
-        FileDescriptionAndFlags* m_description { nullptr };
+        OpenFileDescriptionAndFlags* m_description { nullptr };
     };
 
     class ProcessProcFSTraits : public ProcFSExposedComponent {
@@ -742,8 +742,8 @@ public:
         WeakPtr<Process> m_process;
     };
 
-    FileDescriptions& fds() { return m_fds; }
+    OpenFileDescriptions& fds() { return m_fds; }
-    const FileDescriptions& fds() const { return m_fds; }
+    const OpenFileDescriptions& fds() const { return m_fds; }
 
 private:
     SpinlockProtected<Thread::ListInProcess>& thread_list() { return m_thread_list; }
@@ -751,7 +751,7 @@ private:
 
     SpinlockProtected<Thread::ListInProcess> m_thread_list;
 
-    FileDescriptions m_fds;
+    OpenFileDescriptions m_fds;
 
     const bool m_is_kernel_process;
     Atomic<State> m_state { State::Running };

Kernel/ProcessExposed.cpp

@@ -64,7 +64,7 @@ InodeIndex build_segmented_index_for_thread_stack(ProcessID pid, ThreadID thread
 
 InodeIndex build_segmented_index_for_file_description(ProcessID pid, unsigned fd)
 {
-    return build_segmented_index_with_unknown_property(pid, ProcessSubDirectory::FileDescriptions, fd);
+    return build_segmented_index_with_unknown_property(pid, ProcessSubDirectory::OpenFileDescriptions, fd);
 }
 
 }
@@ -107,7 +107,7 @@ ProcFSExposedLink::ProcFSExposedLink(StringView name)
     : ProcFSExposedComponent(name)
 {
 }
-KResultOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const
+KResultOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     dbgln_if(PROCFS_DEBUG, "ProcFSGlobalInformation @ {}: read_bytes offset: {} count: {}", name(), offset, count);
 
@@ -135,7 +135,7 @@ KResultOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count
     return nread;
 }
 
-KResult ProcFSGlobalInformation::refresh_data(FileDescription& description) const
+KResult ProcFSGlobalInformation::refresh_data(OpenFileDescription& description) const
 {
     MutexLocker lock(m_refresh_lock);
     auto& cached_data = description.data();
@@ -153,7 +153,7 @@ KResult ProcFSGlobalInformation::refresh_data(FileDescription& description) cons
     return KSuccess;
 }
 
-KResultOr<size_t> ProcFSExposedLink::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription*) const
+KResultOr<size_t> ProcFSExposedLink::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     VERIFY(offset == 0);
     MutexLocker locker(m_lock);

Kernel/ProcessExposed.h

@@ -14,8 +14,8 @@
 #include <Kernel/API/KResult.h>
 #include <Kernel/Arch/x86/CPU.h>
 #include <Kernel/FileSystem/File.h>
-#include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/FileSystem/FileSystem.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/KBufferBuilder.h>
 #include <Kernel/UserOrKernelBuffer.h>
 
@@ -26,7 +26,7 @@ enum class MainProcessProperty {
     Reserved = 0,
     Unveil = 1,
     Pledge = 2,
-    FileDescriptions = 3,
+    OpenFileDescriptions = 3,
     BinaryLink = 4,
     CurrentWorkDirectoryLink = 5,
     PerformanceEvents = 6,
@@ -35,7 +35,7 @@ enum class MainProcessProperty {
 
 enum class ProcessSubDirectory {
     Reserved = 0,
-    FileDescriptions = 1,
+    OpenFileDescriptions = 1,
     Stacks = 2,
 };
 
@@ -66,10 +66,10 @@ private:
 class ProcFSExposedComponent : public RefCounted<ProcFSExposedComponent> {
 public:
     StringView name() const { return m_name->view(); }
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, FileDescription*) const { VERIFY_NOT_REACHED(); }
+    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const { VERIFY_NOT_REACHED(); }
     virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const { VERIFY_NOT_REACHED(); }
     virtual KResultOr<NonnullRefPtr<ProcFSExposedComponent>> lookup(StringView) { VERIFY_NOT_REACHED(); };
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer&, FileDescription*) { return KResult(EROFS); }
+    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*) { return KResult(EROFS); }
 
     virtual mode_t required_mode() const { return 0444; }
     virtual UserID owner_user() const { return 0; }
@@ -77,7 +77,7 @@ public:
     time_t modified_time() const { return TimeManagement::now().to_timeval().tv_sec; }
 
     virtual void prepare_for_deletion() { }
-    virtual KResult refresh_data(FileDescription&) const
+    virtual KResult refresh_data(OpenFileDescription&) const
     {
         return KSuccess;
     }
@@ -128,7 +128,7 @@ class ProcFSExposedLink : public ProcFSExposedComponent {
 public:
     virtual KResultOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const override final;
 
-    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const override;
+    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const override;
 
 protected:
     virtual bool acquire_link(KBufferBuilder& builder) = 0;
@@ -149,7 +149,7 @@ private:
     ProcFSRootDirectory();
 };
 
-struct ProcFSInodeData : public FileDescriptionData {
+struct ProcFSInodeData : public OpenFileDescriptionData {
     OwnPtr<KBuffer> buffer;
 };
 
@@ -157,7 +157,7 @@ class ProcFSGlobalInformation : public ProcFSExposedComponent {
 public:
     virtual ~ProcFSGlobalInformation() override {};
 
-    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, FileDescription* description) const override;
+    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const override;
 
     virtual mode_t required_mode() const override { return 0444; }
 
@@ -166,7 +166,7 @@ protected:
         : ProcFSExposedComponent(name)
     {
     }
-    virtual KResult refresh_data(FileDescription&) const override;
+    virtual KResult refresh_data(OpenFileDescription&) const override;
     virtual KResult try_generate(KBufferBuilder&) = 0;
 
     mutable Mutex m_refresh_lock;

Kernel/ProcessProcFSTraits.cpp

@@ -53,11 +53,11 @@ KResult Process::ProcessProcFSTraits::traverse_as_directory(unsigned fsid, Funct
 
     callback({ ".", { fsid, SegmentedProcFSIndex::build_segmented_index_for_pid_directory(process->pid()) }, DT_DIR });
     callback({ "..", { fsid, ProcFSComponentRegistry::the().root_directory().component_index() }, DT_DIR });
-    callback({ "fd", { fsid, SegmentedProcFSIndex::build_segmented_index_for_sub_directory(process->pid(), SegmentedProcFSIndex::ProcessSubDirectory::FileDescriptions) }, DT_DIR });
+    callback({ "fd", { fsid, SegmentedProcFSIndex::build_segmented_index_for_sub_directory(process->pid(), SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions) }, DT_DIR });
     callback({ "stacks", { fsid, SegmentedProcFSIndex::build_segmented_index_for_sub_directory(process->pid(), SegmentedProcFSIndex::ProcessSubDirectory::Stacks) }, DT_DIR });
     callback({ "unveil", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::Unveil) }, DT_REG });
     callback({ "pledge", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::Pledge) }, DT_REG });
-    callback({ "fds", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::FileDescriptions) }, DT_DIR });
+    callback({ "fds", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::OpenFileDescriptions) }, DT_DIR });
     callback({ "exe", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::BinaryLink) }, DT_LNK });
     callback({ "cwd", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink) }, DT_LNK });
     callback({ "perf_events", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents) }, DT_REG });

Kernel/ProcessSpecificExposed.cpp

@@ -184,7 +184,7 @@ KResult Process::procfs_get_fds_stats(KBufferBuilder& builder) const
             return;
         }
         bool cloexec = file_description_metadata.flags() & FD_CLOEXEC;
-        RefPtr<FileDescription> description = file_description_metadata.description();
+        RefPtr<OpenFileDescription> description = file_description_metadata.description();
         auto description_object = array.add_object();
         description_object.add("fd", count);
         description_object.add("absolute_path", description->absolute_path());

Kernel/Storage/PATADiskDevice.cpp

@@ -5,7 +5,7 @@
  */
 
 #include <AK/StringView.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Sections.h>
 #include <Kernel/Storage/IDEChannel.h>
 #include <Kernel/Storage/IDEController.h>

Kernel/Storage/Partition/DiskPartition.cpp

@@ -5,7 +5,7 @@
  */
 
 #include <Kernel/Debug.h>
-#include <Kernel/FileSystem/FileDescription.h>
+#include <Kernel/FileSystem/OpenFileDescription.h>
 #include <Kernel/Storage/Partition/DiskPartition.h>
 
 namespace Kernel {
@@ -37,28 +37,28 @@ void DiskPartition::start_request(AsyncBlockDeviceRequest& request)
         request.block_index() + m_metadata.start_block(), request.block_count(), request.buffer(), request.buffer_size()));
 }
 
-KResultOr<size_t> DiskPartition::read(FileDescription& fd, u64 offset, UserOrKernelBuffer& outbuf, size_t len)
+KResultOr<size_t> DiskPartition::read(OpenFileDescription& fd, u64 offset, UserOrKernelBuffer& outbuf, size_t len)
 {
     unsigned adjust = m_metadata.start_block() * block_size();
     dbgln_if(OFFD_DEBUG, "DiskPartition::read offset={}, adjust={}, len={}", fd.offset(), adjust, len);
     return m_device->read(fd, offset + adjust, outbuf, len);
 }
 
-bool DiskPartition::can_read(const FileDescription& fd, size_t offset) const
+bool DiskPartition::can_read(const OpenFileDescription& fd, size_t offset) const
 {
     unsigned adjust = m_metadata.start_block() * block_size();
     dbgln_if(OFFD_DEBUG, "DiskPartition::can_read offset={}, adjust={}", offset, adjust);
     return m_device->can_read(fd, offset + adjust);
 }
 
-KResultOr<size_t> DiskPartition::write(FileDescription& fd, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
+KResultOr<size_t> DiskPartition::write(OpenFileDescription& fd, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
 {
     unsigned adjust = m_metadata.start_block() * block_size();
     dbgln_if(OFFD_DEBUG, "DiskPartition::write offset={}, adjust={}, len={}", offset, adjust, len);
     return m_device->write(fd, offset + adjust, inbuf, len);
 }
 
-bool DiskPartition::can_write(const FileDescription& fd, size_t offset) const
+bool DiskPartition::can_write(const OpenFileDescription& fd, size_t offset) const
 {
     unsigned adjust = m_metadata.start_block() * block_size();
     dbgln_if(OFFD_DEBUG, "DiskPartition::can_write offset={}, adjust={}", offset, adjust);

Kernel/Storage/Partition/DiskPartition.h

@@ -20,10 +20,10 @@ public:
     virtual void start_request(AsyncBlockDeviceRequest&) override;
 
     // ^BlockDevice
-    virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual bool can_write(const OpenFileDescription&, size_t) const override;
 
     // ^Device
     virtual mode_t required_mode() const override { return 0600; }