RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-10-31 12:42:45 +00:00
Code Issues Activity Actions

Kernel: Rename FileDescription => OpenFileDescription

Browse source 
Dr. POSIX really calls these "open file description", not just
"file description", so let's call them exactly that. :^)
This commit is contained in:
Andreas Kling 2021-09-07 13:39:11 +02:00
parent dbd639a2d8
commit 4a9c18afb9
135 changed files with 680 additions and 680 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/ACPI/Parser.cpp
View file

@ -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)

2
Kernel/ACPI/Parser.h
View file

@ -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;

4
Kernel/Arch/PC/BIOS.cpp
View file

@ -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)

2
Kernel/Arch/PC/BIOS.h
View file

@ -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;

2
Kernel/Bus/PCI/SysFSPCI.cpp
View file

@ -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)

2
Kernel/Bus/PCI/SysFSPCI.h
View file

@ -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:

4
Kernel/Bus/USB/SysFSUSB.cpp
View file

@ -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);

4
Kernel/Bus/USB/SysFSUSB.h
View file

@ -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" };
};

10
Kernel/Bus/VirtIO/ConsolePort.cpp
View file

@ -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);

12
Kernel/Bus/VirtIO/ConsolePort.h
View file

@ -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 KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual bool can_write(const FileDescription&, size_t) const override;
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual KResultOr<NonnullRefPtr<FileDescription>> open(int options) override;
virtual bool can_read(const OpenFileDescription&, size_t) const override;
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual bool can_write(const OpenFileDescription&, size_t) const override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
mode_t required_mode() const override { return 0666; }

4
Kernel/CMakeLists.txt
View file

@ -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

6
Kernel/ConsoleDevice.cpp
View file

@ -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;

8
Kernel/ConsoleDevice.h
View file

@ -23,10 +23,10 @@ public:
virtual ~ConsoleDevice() override;
// ^CharacterDevice
virtual bool can_read(const Kernel::FileDescription&, size_t) const override;
virtual bool can_write(const Kernel::FileDescription&, size_t) const override { return true; }
virtual Kernel::KResultOr<size_t> read(FileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t) override;
virtual Kernel::KResultOr<size_t> write(FileDescription&, u64, const Kernel::UserOrKernelBuffer&, size_t) override;
virtual bool can_read(const Kernel::OpenFileDescription&, size_t) const override;
virtual bool can_write(const Kernel::OpenFileDescription&, size_t) const override { return true; }
virtual Kernel::KResultOr<size_t> read(OpenFileDescription&, u64, 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);

6
Kernel/Coredump.cpp
View file

@ -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()));

6
Kernel/Coredump.h
View file

@ -21,8 +21,8 @@ public:
KResult write();
private:
Coredump(NonnullRefPtr<Process>, NonnullRefPtr<FileDescription>);
static KResultOr<NonnullRefPtr<FileDescription>> try_create_target_file(Process const&, StringView output_path);
Coredump(NonnullRefPtr<Process>, NonnullRefPtr<OpenFileDescription>);
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;
};

2
Kernel/Devices/Device.cpp
View file

@ -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();
}

2
Kernel/Devices/Device.h
View file

@ -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; }

6
Kernel/Devices/FullDevice.cpp
View file

@ -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;

8
Kernel/Devices/FullDevice.h
View file

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

8
Kernel/Devices/HID/KeyboardDevice.cpp
View file

@ -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: {

10
Kernel/Devices/HID/KeyboardDevice.h
View file

@ -25,10 +25,10 @@ public:
virtual ~KeyboardDevice() override;
// ^CharacterDevice
virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual bool can_read(const FileDescription&, size_t) const override;
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual bool can_write(const FileDescription&, size_t) const override { return true; }
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual bool can_read(const OpenFileDescription&, size_t) const override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
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()); }

6
Kernel/Devices/HID/MouseDevice.cpp
View file

@ -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;
}

8
Kernel/Devices/HID/MouseDevice.h
View file

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

8
Kernel/Devices/KCOVDevice.cpp
View file

@ -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);

14
Kernel/Devices/KCOVDevice.h
View file

@ -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<NonnullRefPtr<FileDescription>> open(int options) override;
KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) 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_write(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 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> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
private:
KCOVDevice();

6
Kernel/Devices/MemoryDevice.cpp
View file

@ -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);

12
Kernel/Devices/MemoryDevice.h
View file

@ -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_write(const FileDescription&, size_t) const override { return false; }
virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
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> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
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;
};

6
Kernel/Devices/NullDevice.cpp
View file

@ -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;
}

8
Kernel/Devices/NullDevice.h
View file

@ -25,10 +25,10 @@ public:
private:
// ^CharacterDevice
virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual bool can_write(const FileDescription&, size_t) const override { return true; }
virtual bool can_read(const FileDescription&, size_t) const override;
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
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; }
};

6
Kernel/Devices/RandomDevice.cpp
View file

@ -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;

8
Kernel/Devices/RandomDevice.h
View file

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

8
Kernel/Devices/SB16.cpp
View file

@ -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();

10
Kernel/Devices/SB16.h
View file

@ -27,10 +27,10 @@ public:
static SB16& the();
// ^CharacterDevice
virtual bool can_read(const FileDescription&, size_t) const override;
virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual bool can_write(const FileDescription&, size_t) const override { return true; }
virtual bool can_read(const OpenFileDescription&, size_t) const override;
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
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

8
Kernel/Devices/SerialDevice.cpp
View file

@ -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;

8
Kernel/Devices/SerialDevice.h
View file

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

6
Kernel/Devices/ZeroDevice.cpp
View file

@ -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;
}

8
Kernel/Devices/ZeroDevice.h
View file

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

2
Kernel/FileSystem/AnonymousFile.cpp
View file

@ -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;

12
Kernel/FileSystem/AnonymousFile.h
View file

@ -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 bool can_read(const FileDescription&, size_t) const override { return false; }
virtual bool can_write(const FileDescription&, size_t) const override { return false; }
virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
virtual String absolute_path(const OpenFileDescription&) const override { return ":anonymous-file:"; }
virtual bool can_read(const OpenFileDescription&, size_t) const override { return false; }
virtual bool can_write(const OpenFileDescription&, size_t) const override { return false; }
virtual KResultOr<size_t> read(OpenFileDescription&, u64, 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>);

2
Kernel/FileSystem/BlockBasedFileSystem.cpp
View file

@ -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());

2
Kernel/FileSystem/BlockBasedFileSystem.h
View file

@ -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;

12
Kernel/FileSystem/DevFS.cpp
View file

@ -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);

12
Kernel/FileSystem/DevFS.h
View file

@ -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;

4
Kernel/FileSystem/DevPtsFS.cpp
View file

@ -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();
}

4
Kernel/FileSystem/DevPtsFS.h
View file

@ -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;

10
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -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);

8
Kernel/FileSystem/Ext2FileSystem.h
View file

@ -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;

18
Kernel/FileSystem/FIFO.cpp
View file

@ -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);
}

16
Kernel/FileSystem/FIFO.h
View file

@ -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<FileDescription>> open_direction_blocking(Direction);
KResultOr<NonnullRefPtr<OpenFileDescription>> open_direction(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> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const 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_write(const FileDescription&, size_t) const override;
virtual String absolute_path(const FileDescription&) const override;
virtual bool can_read(const OpenFileDescription&, size_t) const override;
virtual bool can_write(const OpenFileDescription&, size_t) 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; }

14
Kernel/FileSystem/File.cpp
View file

@ -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--;
}

28
Kernel/FileSystem/File.h
View file

@ -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_write(const FileDescription&, size_t) const = 0;
virtual bool can_read(const OpenFileDescription&, size_t) const = 0;
virtual bool can_write(const OpenFileDescription&, size_t) const = 0;
virtual KResult attach(FileDescription&);
virtual void detach(FileDescription&);
virtual void did_seek(FileDescription&, off_t) { }
virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) = 0;
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) = 0;
virtual KResult ioctl(FileDescription&, unsigned request, Userspace<void*> arg);
virtual KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
virtual KResult attach(OpenFileDescription&);
virtual void detach(OpenFileDescription&);
virtual void did_seek(OpenFileDescription&, off_t) { }
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) = 0;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) = 0;
virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg);
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 chmod(FileDescription&, mode_t) { return EBADF; }
virtual KResult chown(OpenFileDescription&, UserID, GroupID) { return EBADF; }
virtual KResult chmod(OpenFileDescription&, mode_t) { return EBADF; }
virtual StringView class_name() const = 0;

2
Kernel/FileSystem/FileBackedFileSystem.cpp
View file

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

10
Kernel/FileSystem/FileBackedFileSystem.h
View file

@ -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;
};
}

8
Kernel/FileSystem/ISO9660FileSystem.cpp
View file

@ -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;
}

8
Kernel/FileSystem/ISO9660FileSystem.h
View file

@ -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;

14
Kernel/FileSystem/Inode.cpp
View file

@ -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);

24
Kernel/FileSystem/Inode.h
View file

@ -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 void detach(FileDescription&) { }
virtual void did_seek(FileDescription&, off_t) { }
virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const = 0;
virtual KResult attach(OpenFileDescription&) { return KSuccess; }
virtual void detach(OpenFileDescription&) { }
virtual void did_seek(OpenFileDescription&, off_t) { }
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 apply_flock(Process const&, FileDescription const&, Userspace<flock const*>);
KResult get_flock(FileDescription const&, Userspace<flock*>) const;
void remove_flocks_for_description(FileDescription const&);
KResult can_apply_flock(OpenFileDescription const&, flock const&) const;
KResult apply_flock(Process const&, OpenFileDescription const&, Userspace<flock const*>);
KResult get_flock(OpenFileDescription const&, Userspace<flock*>) 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;
};

16
Kernel/FileSystem/InodeFile.cpp
View file

@ -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());

18
Kernel/FileSystem/InodeFile.h
View file

@ -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_write(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 OpenFileDescription&, size_t) const override { return true; }
virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual KResult ioctl(FileDescription&, 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<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) 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 chmod(FileDescription&, mode_t) override;
virtual KResult chown(OpenFileDescription&, UserID, GroupID) override;
virtual KResult chmod(OpenFileDescription&, mode_t) override;
virtual StringView class_name() const override { return "InodeFile"; }

6
Kernel/FileSystem/InodeWatcher.cpp
View file

@ -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());
}

10
Kernel/FileSystem/InodeWatcher.h
View file

@ -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 KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual bool can_read(const OpenFileDescription&, size_t) const 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 KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EIO; }
virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
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; }

96
Kernel/FileSystem/FileDescription.cpp → Kernel/FileSystem/OpenFileDescription.cpp
View file

@ -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;

22
Kernel/FileSystem/FileDescription.h → Kernel/FileSystem/OpenFileDescription.h
View file

@ -18,17 +18,17 @@
namespace Kernel {
class FileDescriptionData {
class OpenFileDescriptionData {
public:
virtual ~FileDescriptionData() = default;
virtual ~OpenFileDescriptionData() = default;
};
class FileDescription : public RefCounted<FileDescription> {
MAKE_SLAB_ALLOCATED(FileDescription)
class OpenFileDescription : public RefCounted<OpenFileDescription> {
MAKE_SLAB_ALLOCATED(OpenFileDescription)
public:
static KResultOr<NonnullRefPtr<FileDescription>> try_create(Custody&);
static KResultOr<NonnullRefPtr<FileDescription>> try_create(File&);
~FileDescription();
static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create(Custody&);
static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create(File&);
~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" };
};
}

8
Kernel/FileSystem/Plan9FileSystem.cpp
View file

@ -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);

8
Kernel/FileSystem/Plan9FileSystem.h
View file

@ -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> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, FileDescription*) 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, 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;

46
Kernel/FileSystem/ProcFS.cpp
View file

@ -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.

34
Kernel/FileSystem/ProcFS.h
View file

@ -54,8 +54,8 @@ protected:
ProcFS const& procfs() const { return static_cast<ProcFS const&>(Inode::fs()); }
// ^Inode
virtual KResult attach(FileDescription& description) = 0;
virtual void did_seek(FileDescription&, off_t) = 0;
virtual KResult attach(OpenFileDescription& description) = 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 KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, FileDescription*) const override final;
virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, FileDescription*) override final;
virtual void did_seek(FileDescription&, off_t) override final;
virtual KResult attach(OpenFileDescription& description) 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, OpenFileDescription*) 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 void did_seek(FileDescription&, off_t) override { }
virtual KResult attach(OpenFileDescription& description) 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 void did_seek(FileDescription&, off_t) override;
virtual KResult attach(OpenFileDescription& description) 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 void did_seek(FileDescription&, off_t) override;
virtual KResult attach(OpenFileDescription& description) 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;

8
Kernel/FileSystem/SysFS.cpp
View file

@ -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);
}

8
Kernel/FileSystem/SysFS.h
View file

@ -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 void did_seek(FileDescription&, off_t) override final;
virtual KResult attach(OpenFileDescription& description) override final;
virtual void did_seek(OpenFileDescription&, off_t) override final;
NonnullRefPtr<SysFSComponent> m_associated_component;
};

10
Kernel/FileSystem/SysFSComponent.h
View file

@ -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 KResult refresh_data(FileDescription&) const { return KSuccess; }
virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) { return EROFS; }
virtual KResult refresh_data(OpenFileDescription&) const { return KSuccess; }
virtual KResultOr<NonnullRefPtr<SysFSInode>> to_inode(SysFS const&) const;

4
Kernel/FileSystem/TmpFS.cpp
View file

@ -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());

4
Kernel/FileSystem/TmpFS.h
View file

@ -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;

10
Kernel/FileSystem/VirtualFileSystem.cpp
View file

@ -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;

6
Kernel/FileSystem/VirtualFileSystem.h
View file

@ -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<FileDescription>> create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> = {});
KResultOr<NonnullRefPtr<OpenFileDescription>> open(StringView path, int options, mode_t mode, Custody& base, 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);

2
Kernel/Forward.h
View file

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

2
Kernel/GlobalProcessExposed.cpp
View file

@ -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>

4
Kernel/Graphics/FramebufferDevice.cpp
View file

@ -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) {

12
Kernel/Graphics/FramebufferDevice.h
View file

@ -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 KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) 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_write(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 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> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
virtual KResultOr<size_t> read(OpenFileDescription&, u64, 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);

4
Kernel/Graphics/VirtIOGPU/FrameBufferDevice.cpp
View file

@ -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)

12
Kernel/Graphics/VirtIOGPU/FrameBufferDevice.h
View file

@ -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 KResultOr<Memory::Region*> mmap(Process&, FileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
virtual bool can_read(const FileDescription&, size_t) const override { return true; }
virtual KResultOr<size_t> read(FileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
virtual bool can_write(const FileDescription&, size_t) const override { return true; }
virtual KResultOr<size_t> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; };
virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
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; }

2
Kernel/KSyms.cpp
View file

@ -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>

24
Kernel/Net/IPv4Socket.cpp
View file

@ -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);

22
Kernel/Net/IPv4Socket.h
View file

@ -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_write(const FileDescription&, 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> recvfrom(FileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
virtual bool can_read(const OpenFileDescription&, size_t) const override;
virtual bool can_write(const OpenFileDescription&, size_t) const override;
virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) 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_packet_buffered(FileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&);
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(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&);
void set_can_read(bool);

50
Kernel/Net/LocalSocket.cpp
View file

@ -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);

54
Kernel/Net/LocalSocket.h
View file

@ -12,11 +12,11 @@
namespace Kernel {
class FileDescription;
class OpenFileDescription;
struct SocketPair {
NonnullRefPtr<FileDescription> description0;
NonnullRefPtr<FileDescription> description1;
NonnullRefPtr<OpenFileDescription> description0;
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);
KResultOr<NonnullRefPtr<FileDescription>> recvfd(const FileDescription& socket_description);
KResult sendfd(const OpenFileDescription& socket_description, OpenFileDescription& passing_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 void detach(FileDescription&) override;
virtual bool can_read(const FileDescription&, size_t) const override;
virtual bool can_write(const FileDescription&, 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> recvfrom(FileDescription&, 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 ioctl(FileDescription&, unsigned request, Userspace<void*> arg) override;
virtual KResult chown(FileDescription&, UserID, GroupID) override;
virtual KResult chmod(FileDescription&, mode_t) override;
virtual KResult attach(OpenFileDescription&) override;
virtual void detach(OpenFileDescription&) override;
virtual bool can_read(const OpenFileDescription&, size_t) const override;
virtual bool can_write(const OpenFileDescription&, size_t) const override;
virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
virtual KResultOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
virtual KResult getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
virtual KResult chown(OpenFileDescription&, UserID, GroupID) 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;
DoubleBuffer* receive_buffer_for(FileDescription&);
DoubleBuffer* send_buffer_for(FileDescription&);
NonnullRefPtrVector<FileDescription>& sendfd_queue_for(const FileDescription&);
NonnullRefPtrVector<FileDescription>& recvfd_queue_for(const FileDescription&);
bool has_attached_peer(const OpenFileDescription&) const;
DoubleBuffer* receive_buffer_for(OpenFileDescription&);
DoubleBuffer* send_buffer_for(OpenFileDescription&);
NonnullRefPtrVector<OpenFileDescription>& sendfd_queue_for(const OpenFileDescription&);
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<FileDescription> m_fds_for_server;
NonnullRefPtrVector<OpenFileDescription> m_fds_for_client;
NonnullRefPtrVector<OpenFileDescription> m_fds_for_server;
IntrusiveListNode<LocalSocket> m_list_node;

8
Kernel/Net/Socket.cpp
View file

@ -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);

18
Kernel/Net/Socket.h
View file

@ -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> recvfrom(FileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) = 0;
virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int flags, Userspace<const sockaddr*>, socklen_t) = 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> write(FileDescription&, u64, const UserOrKernelBuffer&, size_t) override final;
virtual KResultOr<size_t> read(OpenFileDescription&, u64, 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; }

6
Kernel/Net/TCPSocket.cpp
View file

@ -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;

4
Kernel/Net/TCPSocket.h
View file

@ -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;

2
Kernel/Net/UDPSocket.cpp
View file

@ -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);

2
Kernel/Net/UDPSocket.h
View file

@ -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;
};

24
Kernel/Process.cpp
View file

@ -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);

62
Kernel/Process.h
View file

@ -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);
KResultOr<FlatPtr> do_write(FileDescription&, const UserOrKernelBuffer&, size_t);
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(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; }
const FileDescription* description() const { return m_description; }
OpenFileDescription* description() { 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 {
AK_MAKE_NONCOPYABLE(FileDescriptions);
class OpenFileDescriptions {
AK_MAKE_NONCOPYABLE(OpenFileDescriptions);
friend class Process;
public:
ALWAYS_INLINE const FileDescriptionAndFlags& operator[](size_t i) const { return at(i); }
ALWAYS_INLINE FileDescriptionAndFlags& operator[](size_t i) { return at(i); }
ALWAYS_INLINE const OpenFileDescriptionAndFlags& operator[](size_t i) const { 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;
FileDescriptionAndFlags& at(size_t i);
const OpenFileDescriptionAndFlags& at(size_t i) const;
OpenFileDescriptionAndFlags& at(size_t i);
FileDescriptionAndFlags const* get_if_valid(size_t i) const;
FileDescriptionAndFlags* get_if_valid(size_t i);
OpenFileDescriptionAndFlags const* get_if_valid(size_t i) const;
OpenFileDescriptionAndFlags* get_if_valid(size_t i);
void enumerate(Function<void(const FileDescriptionAndFlags&)>) const;
void change_each(Function<void(FileDescriptionAndFlags&)>);
void enumerate(Function<void(const OpenFileDescriptionAndFlags&)>) const;
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; }
const FileDescriptions& fds() const { return m_fds; }
OpenFileDescriptions& fds() { 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 };

8
Kernel/ProcessExposed.cpp
View file

@ -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);

20
Kernel/ProcessExposed.h
View file

@ -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;

4
Kernel/ProcessProcFSTraits.cpp
View file

@ -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 });

2
Kernel/ProcessSpecificExposed.cpp
View file

@ -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());

2
Kernel/Storage/PATADiskDevice.cpp
View file

@ -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>

10
Kernel/Storage/Partition/DiskPartition.cpp
View file

@ -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);

8
Kernel/Storage/Partition/DiskPartition.h
View file

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

Some files were not shown because too many files have changed in this diff Show more