RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 11:17:35 +00:00
Code Issues Activity Actions

Kernel: Introduce the DeviceManagement singleton

Browse source 
This singleton simplifies many aspects that we struggled with before:
1. There's no need to make derived classes of Device expose the
constructor as public anymore. The singleton is a friend of them, so he
can call the constructor. This solves the issue with try_create_device
helper neatly, hopefully for good.
2. Getting a reference of the NullDevice is now being done from this
singleton, which means that NullDevice no longer needs to use its own
singleton, and we can apply the try_create_device helper on it too :)
3. We can now defer registration completely after the Device constructor
which means the Device constructor is merely assigning the major and
minor numbers of the Device, and the try_create_device helper ensures it
calls the after_inserting method immediately after construction. This
creates a great opportunity to make registration more OOM-safe.
This commit is contained in:
Liav A 2021-09-11 09:19:20 +03:00 • committed by Idan Horowitz
parent 9aa6dd6b78
commit aee4786d8e
43 changed files with 244 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

45
Kernel/Devices/Device.cpp
View file

@ -6,20 +6,13 @@
#include <AK/Singleton.h>
#include <Kernel/Devices/Device.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/FileSystem/InodeMetadata.h>
#include <Kernel/FileSystem/SysFS.h>
#include <Kernel/Locking/MutexProtected.h>
#include <Kernel/Sections.h>
namespace Kernel {
static Singleton<MutexProtected<HashMap<u32, Device*>>> s_all_devices;
MutexProtected<HashMap<u32, Device*>>& Device::all_devices()
{
return *s_all_devices;
}
NonnullRefPtr<SysFSDeviceComponent> SysFSDeviceComponent::must_create(Device const& device)
{
return adopt_ref_if_nonnull(new SysFSDeviceComponent(device)).release_nonnull();
@ -115,41 +108,15 @@ RefPtr<SysFSComponent> SysFSCharacterDevicesDirectory::lookup(StringView name)
});
}
void Device::for_each(Function<void(Device&)> callback)
{
all_devices().with_exclusive([&](auto& map) -> void {
for (auto& entry : map)
callback(*entry.value);
});
}
Device* Device::get_device(unsigned major, unsigned minor)
{
return all_devices().with_exclusive([&](auto& map) -> Device* {
auto it = map.find(encoded_device(major, minor));
if (it == map.end())
return nullptr;
return it->value;
});
}
Device::Device(unsigned major, unsigned minor)
: m_major(major)
, m_minor(minor)
{
u32 device_id = encoded_device(major, minor);
all_devices().with_exclusive([&](auto& map) -> void {
auto it = map.find(device_id);
if (it != map.end()) {
dbgln("Already registered {},{}: {}", major, minor, it->value->class_name());
}
VERIFY(!map.contains(device_id));
map.set(device_id, this);
});
}
void Device::after_inserting()
{
DeviceManagement::the().after_inserting_device({}, *this);
VERIFY(!m_sysfs_component);
auto sys_fs_component = SysFSDeviceComponent::must_create(*this);
m_sysfs_component = sys_fs_component;
@ -160,21 +127,17 @@ void Device::after_inserting()
void Device::before_removing()
{
m_state = State::BeingRemoved;
VERIFY(m_sysfs_component);
SysFSComponentRegistry::the().devices_list().with_exclusive([&](auto& list) -> void {
list.remove(*m_sysfs_component);
});
DeviceManagement::the().before_device_removal({}, *this);
m_state = State::BeingRemoved;
}
Device::~Device()
{
VERIFY(m_state == State::BeingRemoved);
u32 device_id = encoded_device(m_major, m_minor);
all_devices().with_exclusive([&](auto& map) -> void {
VERIFY(map.contains(device_id));
map.remove(encoded_device(m_major, m_minor));
});
}
String Device::absolute_path() const

14
Kernel/Devices/Device.h
View file

@ -27,14 +27,6 @@
namespace Kernel {
template<typename DeviceType, typename... Args>
inline KResultOr<NonnullRefPtr<DeviceType>> try_create_device(Args&&... args)
{
auto device = TRY(adopt_nonnull_ref_or_enomem(new DeviceType(forward<Args>(args)...)));
device->after_inserting();
return device;
}
class Device : public File {
protected:
enum class State {
@ -57,10 +49,6 @@ public:
virtual bool is_device() const override { return true; }
virtual void before_removing() override;
virtual void after_inserting();
static void for_each(Function<void(Device&)>);
static Device* get_device(unsigned major, unsigned minor);
void process_next_queued_request(Badge<AsyncDeviceRequest>, const AsyncDeviceRequest&);
template<typename AsyncRequestType, typename... Args>
@ -80,8 +68,6 @@ protected:
void set_uid(UserID uid) { m_uid = uid; }
void set_gid(GroupID gid) { m_gid = gid; }
static MutexProtected<HashMap<u32, Device*>>& all_devices();
private:
unsigned m_major { 0 };
unsigned m_minor { 0 };

88
Kernel/Devices/DeviceManagement.cpp Normal file
View file

@ -0,0 +1,88 @@
/*
* Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/HashTable.h>
#include <AK/Singleton.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/FileSystem/InodeMetadata.h>
#include <Kernel/Sections.h>
namespace Kernel {
static Singleton<DeviceManagement> s_the;
UNMAP_AFTER_INIT DeviceManagement::DeviceManagement()
{
}
UNMAP_AFTER_INIT void DeviceManagement::initialize()
{
s_the.ensure_instance();
}
UNMAP_AFTER_INIT void DeviceManagement::attach_null_device(NullDevice const& device)
{
m_null_device = device;
}
DeviceManagement& DeviceManagement::the()
{
return *s_the;
}
Device* DeviceManagement::get_device(unsigned major, unsigned minor)
{
return m_devices.with_exclusive([&](auto& map) -> Device* {
auto it = map.find(encoded_device(major, minor));
if (it == map.end())
return nullptr;
return it->value;
});
}
void DeviceManagement::before_device_removal(Badge<Device>, Device& device)
{
u32 device_id = encoded_device(device.major(), device.minor());
m_devices.with_exclusive([&](auto& map) -> void {
VERIFY(map.contains(device_id));
map.remove(encoded_device(device.major(), device.minor()));
});
}
void DeviceManagement::after_inserting_device(Badge<Device>, Device& device)
{
u32 device_id = encoded_device(device.major(), device.minor());
m_devices.with_exclusive([&](auto& map) -> void {
if (map.contains(device_id)) {
dbgln("Already registered {},{}: {}", device.major(), device.minor(), device.class_name());
VERIFY_NOT_REACHED();
}
auto result = map.set(device_id, &device);
if (result != AK::HashSetResult::InsertedNewEntry) {
dbgln("Failed to register {},{}: {}", device.major(), device.minor(), device.class_name());
VERIFY_NOT_REACHED();
}
});
}
void DeviceManagement::for_each(Function<void(Device&)> callback)
{
m_devices.with_exclusive([&](auto& map) -> void {
for (auto& entry : map)
callback(*entry.value);
});
}
NullDevice& DeviceManagement::null_device()
{
return *m_null_device;
}
NullDevice const& DeviceManagement::null_device() const
{
return *m_null_device;
}
}

54
Kernel/Devices/DeviceManagement.h Normal file
View file

@ -0,0 +1,54 @@
/*
* Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/Badge.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/OwnPtr.h>
#include <AK/RefPtr.h>
#include <AK/Time.h>
#include <AK/Types.h>
#include <Kernel/API/KResult.h>
#include <Kernel/API/TimePage.h>
#include <Kernel/Arch/x86/RegisterState.h>
#include <Kernel/Devices/Device.h>
#include <Kernel/Devices/NullDevice.h>
#include <Kernel/UnixTypes.h>
namespace Kernel {
class DeviceManagement {
AK_MAKE_ETERNAL;
public:
DeviceManagement();
static void initialize();
static DeviceManagement& the();
void attach_null_device(NullDevice const&);
void after_inserting_device(Badge<Device>, Device&);
void before_device_removal(Badge<Device>, Device&);
void for_each(Function<void(Device&)>);
Device* get_device(unsigned major, unsigned minor);
NullDevice const& null_device() const;
NullDevice& null_device();
template<typename DeviceType, typename... Args>
static inline KResultOr<NonnullRefPtr<DeviceType>> try_create_device(Args&&... args)
{
auto device = TRY(adopt_nonnull_ref_or_enomem(new DeviceType(forward<Args>(args)...)));
device->after_inserting();
return device;
}
private:
RefPtr<NullDevice> m_null_device;
MutexProtected<HashMap<u32, Device*>> m_devices;
};
}

3
Kernel/Devices/FullDevice.cpp
View file

@ -5,6 +5,7 @@
*/
#include <AK/Memory.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/FullDevice.h>
#include <Kernel/Sections.h>
#include <LibC/errno_numbers.h>
@ -13,7 +14,7 @@ namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<FullDevice> FullDevice::must_create()
{
auto full_device_or_error = try_create_device<FullDevice>();
auto full_device_or_error = DeviceManagement::try_create_device<FullDevice>();
// FIXME: Find a way to propagate errors
VERIFY(!full_device_or_error.is_error());
return full_device_or_error.release_value();

5
Kernel/Devices/FullDevice.h
View file

@ -12,14 +12,15 @@ namespace Kernel {
class FullDevice final : public CharacterDevice {
AK_MAKE_ETERNAL
friend class DeviceManagement;
public:
static NonnullRefPtr<FullDevice> must_create();
virtual ~FullDevice() override;
// FIXME: We expose this constructor to make try_create_device helper to work
private:
FullDevice();
private:
// ^CharacterDevice
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;

3
Kernel/Devices/HID/PS2KeyboardDevice.cpp
View file

@ -9,6 +9,7 @@
#include <AK/Singleton.h>
#include <AK/Types.h>
#include <Kernel/Debug.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/HID/HIDManagement.h>
#include <Kernel/Devices/HID/PS2KeyboardDevice.h>
#include <Kernel/IO.h>
@ -83,7 +84,7 @@ bool PS2KeyboardDevice::handle_irq(const RegisterState&)
UNMAP_AFTER_INIT RefPtr<PS2KeyboardDevice> PS2KeyboardDevice::try_to_initialize(const I8042Controller& ps2_controller)
{
auto keyboard_device_or_error = try_create_device<PS2KeyboardDevice>(ps2_controller);
auto keyboard_device_or_error = DeviceManagement::try_create_device<PS2KeyboardDevice>(ps2_controller);
// FIXME: Find a way to propagate errors
VERIFY(!keyboard_device_or_error.is_error());
if (keyboard_device_or_error.value()->initialize())

5
Kernel/Devices/HID/PS2KeyboardDevice.h
View file

@ -21,6 +21,8 @@ namespace Kernel {
class PS2KeyboardDevice final : public IRQHandler
, public KeyboardDevice
, public I8042Device {
friend class DeviceManagement;
public:
static RefPtr<PS2KeyboardDevice> try_to_initialize(const I8042Controller&);
virtual ~PS2KeyboardDevice() override;
@ -35,10 +37,9 @@ public:
enable_irq();
}
// FIXME: We expose this constructor to make try_create_device helper to work
private:
explicit PS2KeyboardDevice(const I8042Controller&);
private:
// ^IRQHandler
virtual bool handle_irq(const RegisterState&) override;

3
Kernel/Devices/HID/PS2MouseDevice.cpp
View file

@ -6,6 +6,7 @@
#include <AK/Memory.h>
#include <Kernel/Debug.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/HID/PS2MouseDevice.h>
#include <Kernel/Devices/VMWareBackdoor.h>
#include <Kernel/IO.h>
@ -174,7 +175,7 @@ void PS2MouseDevice::set_sample_rate(u8 rate)
UNMAP_AFTER_INIT RefPtr<PS2MouseDevice> PS2MouseDevice::try_to_initialize(const I8042Controller& ps2_controller)
{
auto mouse_device_or_error = try_create_device<PS2MouseDevice>(ps2_controller);
auto mouse_device_or_error = DeviceManagement::try_create_device<PS2MouseDevice>(ps2_controller);
// FIXME: Find a way to propagate errors
VERIFY(!mouse_device_or_error.is_error());
if (mouse_device_or_error.value()->initialize())

5
Kernel/Devices/HID/PS2MouseDevice.h
View file

@ -17,6 +17,8 @@ namespace Kernel {
class PS2MouseDevice : public IRQHandler
, public MouseDevice
, public I8042Device {
friend class DeviceManagement;
public:
static RefPtr<PS2MouseDevice> try_to_initialize(const I8042Controller&);
bool initialize();
@ -32,10 +34,9 @@ public:
enable_irq();
}
// FIXME: We expose this constructor to make try_create_device helper to work
protected:
explicit PS2MouseDevice(const I8042Controller&);
protected:
// ^IRQHandler
virtual bool handle_irq(const RegisterState&) override;

3
Kernel/Devices/HID/VMWareMouseDevice.cpp
View file

@ -4,6 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/HID/VMWareMouseDevice.h>
#include <Kernel/Devices/VMWareBackdoor.h>
#include <Kernel/Sections.h>
@ -16,7 +17,7 @@ UNMAP_AFTER_INIT RefPtr<VMWareMouseDevice> VMWareMouseDevice::try_to_initialize(
return {};
if (!VMWareBackdoor::the()->vmmouse_is_absolute())
return {};
auto mouse_device_or_error = try_create_device<VMWareMouseDevice>(ps2_controller);
auto mouse_device_or_error = DeviceManagement::try_create_device<VMWareMouseDevice>(ps2_controller);
// FIXME: Find a way to propagate errors
VERIFY(!mouse_device_or_error.is_error());
if (mouse_device_or_error.value()->initialize())

3
Kernel/Devices/HID/VMWareMouseDevice.h
View file

@ -17,13 +17,14 @@ namespace Kernel {
class VMWareMouseDevice final : public PS2MouseDevice {
public:
friend class DeviceManagement;
static RefPtr<VMWareMouseDevice> try_to_initialize(const I8042Controller&);
virtual ~VMWareMouseDevice() override;
// ^I8042Device
virtual void irq_handle_byte_read(u8 byte) override;
// FIXME: We expose this constructor to make try_create_device helper to work
private:
explicit VMWareMouseDevice(const I8042Controller&);
};

3
Kernel/Devices/KCOVDevice.cpp
View file

@ -6,6 +6,7 @@
#include <AK/Assertions.h>
#include <AK/NonnullOwnPtr.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/KCOVDevice.h>
#include <Kernel/Devices/KCOVInstance.h>
#include <Kernel/FileSystem/OpenFileDescription.h>
@ -20,7 +21,7 @@ HashMap<ThreadID, KCOVInstance*>* KCOVDevice::thread_instance;
UNMAP_AFTER_INIT NonnullRefPtr<KCOVDevice> KCOVDevice::must_create()
{
auto kcov_device_or_error = try_create_device<KCOVDevice>();
auto kcov_device_or_error = DeviceManagement::try_create_device<KCOVDevice>();
// FIXME: Find a way to propagate errors
VERIFY(!kcov_device_or_error.is_error());
return kcov_device_or_error.release_value();

4
Kernel/Devices/KCOVDevice.h
View file

@ -12,6 +12,7 @@
namespace Kernel {
class KCOVDevice final : public BlockDevice {
AK_MAKE_ETERNAL
friend class DeviceManagement;
public:
static HashMap<ProcessID, KCOVInstance*>* proc_instance;
@ -25,10 +26,9 @@ public:
KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
// FIXME: We expose this constructor to make try_create_device helper to work
protected:
KCOVDevice();
protected:
virtual StringView class_name() const override { return "KCOVDevice"; }
virtual bool can_read(const OpenFileDescription&, size_t) const override final { return true; }

3
Kernel/Devices/MemoryDevice.cpp
View file

@ -6,6 +6,7 @@
#include <AK/Memory.h>
#include <AK/StdLibExtras.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/MemoryDevice.h>
#include <Kernel/Firmware/BIOS.h>
#include <Kernel/Memory/AnonymousVMObject.h>
@ -15,7 +16,7 @@ namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<MemoryDevice> MemoryDevice::must_create()
{
auto memory_device_or_error = try_create_device<MemoryDevice>();
auto memory_device_or_error = DeviceManagement::try_create_device<MemoryDevice>();
// FIXME: Find a way to propagate errors
VERIFY(!memory_device_or_error.is_error());
return memory_device_or_error.release_value();

5
Kernel/Devices/MemoryDevice.h
View file

@ -15,16 +15,17 @@ namespace Kernel {
class MemoryDevice final : public CharacterDevice {
AK_MAKE_ETERNAL
friend class DeviceManagement;
public:
static NonnullRefPtr<MemoryDevice> must_create();
~MemoryDevice();
virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
// FIXME: We expose this constructor to make try_create_device helper to work
private:
MemoryDevice();
private:
virtual StringView class_name() const override { return "MemoryDevice"; }
virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
virtual bool can_write(const OpenFileDescription&, size_t) const override { return false; }

16
Kernel/Devices/NullDevice.cpp
View file

@ -5,22 +5,18 @@
*/
#include <AK/Singleton.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/NullDevice.h>
#include <Kernel/Sections.h>
namespace Kernel {
static Singleton<NullDevice> s_the;
UNMAP_AFTER_INIT void NullDevice::initialize()
UNMAP_AFTER_INIT NonnullRefPtr<NullDevice> NullDevice::must_initialize()
{
s_the.ensure_instance();
s_the->after_inserting();
}
NullDevice& NullDevice::the()
{
return *s_the;
auto null_device_or_error = DeviceManagement::try_create_device<NullDevice>();
// FIXME: Find a way to propagate errors
VERIFY(!null_device_or_error.is_error());
return null_device_or_error.release_value();
}
UNMAP_AFTER_INIT NullDevice::NullDevice()

7
Kernel/Devices/NullDevice.h
View file

@ -12,14 +12,15 @@ namespace Kernel {
class NullDevice final : public CharacterDevice {
AK_MAKE_ETERNAL
friend class DeviceManagement;
public:
NullDevice();
virtual ~NullDevice() override;
static void initialize();
static NullDevice& the();
static NonnullRefPtr<NullDevice> must_initialize();
private:
NullDevice();
// ^CharacterDevice
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;

3
Kernel/Devices/RandomDevice.cpp
View file

@ -4,6 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/RandomDevice.h>
#include <Kernel/Random.h>
#include <Kernel/Sections.h>
@ -12,7 +13,7 @@ namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<RandomDevice> RandomDevice::must_create()
{
auto random_device_or_error = try_create_device<RandomDevice>();
auto random_device_or_error = DeviceManagement::try_create_device<RandomDevice>();
// FIXME: Find a way to propagate errors
VERIFY(!random_device_or_error.is_error());
return random_device_or_error.release_value();

5
Kernel/Devices/RandomDevice.h
View file

@ -12,14 +12,15 @@ namespace Kernel {
class RandomDevice final : public CharacterDevice {
AK_MAKE_ETERNAL
friend class DeviceManagement;
public:
static NonnullRefPtr<RandomDevice> must_create();
virtual ~RandomDevice() override;
// FIXME: We expose this constructor to make try_create_device helper to work
private:
RandomDevice();
private:
// ^CharacterDevice
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;

9
Kernel/Devices/SerialDevice.cpp
View file

@ -5,6 +5,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/SerialDevice.h>
#include <Kernel/IO.h>
#include <Kernel/Sections.h>
@ -23,19 +24,19 @@ UNMAP_AFTER_INIT NonnullRefPtr<SerialDevice> SerialDevice::must_create(size_t co
RefPtr<SerialDevice> serial_device;
switch (com_number) {
case 0: {
serial_device = try_create_device<SerialDevice>(IOAddress(SERIAL_COM1_ADDR), 64).release_value();
serial_device = DeviceManagement::try_create_device<SerialDevice>(IOAddress(SERIAL_COM1_ADDR), 64).release_value();
break;
}
case 1: {
serial_device = try_create_device<SerialDevice>(IOAddress(SERIAL_COM2_ADDR), 65).release_value();
serial_device = DeviceManagement::try_create_device<SerialDevice>(IOAddress(SERIAL_COM2_ADDR), 65).release_value();
break;
}
case 2: {
serial_device = try_create_device<SerialDevice>(IOAddress(SERIAL_COM3_ADDR), 66).release_value();
serial_device = DeviceManagement::try_create_device<SerialDevice>(IOAddress(SERIAL_COM3_ADDR), 66).release_value();
break;
}
case 3: {
serial_device = try_create_device<SerialDevice>(IOAddress(SERIAL_COM4_ADDR), 67).release_value();
serial_device = DeviceManagement::try_create_device<SerialDevice>(IOAddress(SERIAL_COM4_ADDR), 67).release_value();
break;
}
default:

5
Kernel/Devices/SerialDevice.h
View file

@ -13,6 +13,8 @@ namespace Kernel {
class SerialDevice final : public CharacterDevice {
AK_MAKE_ETERNAL
friend class DeviceManagement;
public:
static NonnullRefPtr<SerialDevice> must_create(size_t com_number);
@ -102,10 +104,9 @@ public:
DataReady = 0x01 << 0
};
// FIXME: We expose this constructor to make try_create_device helper to work
private:
SerialDevice(IOAddress base_addr, unsigned minor);
private:
friend class PCISerialDevice;
// ^CharacterDevice

3
Kernel/Devices/ZeroDevice.cpp
View file

@ -5,6 +5,7 @@
*/
#include <AK/Memory.h>
#include <Kernel/Devices/DeviceManagement.h>
#include <Kernel/Devices/ZeroDevice.h>
#include <Kernel/Sections.h>
@ -12,7 +13,7 @@ namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<ZeroDevice> ZeroDevice::must_create()
{
auto zero_device_or_error = try_create_device<ZeroDevice>();
auto zero_device_or_error = DeviceManagement::try_create_device<ZeroDevice>();
// FIXME: Find a way to propagate errors
VERIFY(!zero_device_or_error.is_error());
return zero_device_or_error.release_value();

5
Kernel/Devices/ZeroDevice.h
View file

@ -12,14 +12,15 @@ namespace Kernel {
class ZeroDevice final : public CharacterDevice {
AK_MAKE_ETERNAL
friend class DeviceManagement;
public:
static NonnullRefPtr<ZeroDevice> must_create();
virtual ~ZeroDevice() override;
// FIXME: We expose this constructor to make try_create_device helper to work
private:
ZeroDevice();
private:
// ^CharacterDevice
virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;