Kernel: Move a bunch of generic devices code into new subdirectory

Kernel/Devices/Generic/ConsoleDevice.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Platform.h>
+#if ARCH(X86_64)
+#    include <Kernel/Arch/x86_64/BochsDebugOutput.h>
+#endif
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/ConsoleDevice.h>
+#include <Kernel/Locking/Spinlock.h>
+#include <Kernel/Sections.h>
+#include <Kernel/kstdio.h>
+
+namespace Kernel {
+
+Spinlock<LockRank::None> g_console_lock {};
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<ConsoleDevice> ConsoleDevice::must_create()
+{
+    auto device_or_error = DeviceManagement::try_create_device<ConsoleDevice>();
+    VERIFY(!device_or_error.is_error());
+    return device_or_error.release_value();
+}
+
+UNMAP_AFTER_INIT ConsoleDevice::ConsoleDevice()
+    : CharacterDevice(5, 1)
+{
+}
+
+UNMAP_AFTER_INIT ConsoleDevice::~ConsoleDevice() = default;
+
+bool ConsoleDevice::can_read(Kernel::OpenFileDescription const&, u64) const
+{
+    return false;
+}
+
+ErrorOr<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;
+}
+
+ErrorOr<size_t> ConsoleDevice::write(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer const& data, size_t size)
+{
+    if (!size)
+        return 0;
+
+    return data.read_buffered<256>(size, [&](ReadonlyBytes readonly_bytes) {
+        for (const auto& byte : readonly_bytes)
+            put_char(byte);
+        return readonly_bytes.size();
+    });
+}
+
+void ConsoleDevice::put_char(char ch)
+{
+    Kernel::SpinlockLocker lock(g_console_lock);
+    dbgputchar(ch);
+    m_logbuffer.enqueue(ch);
+}
+
+}

Kernel/Devices/Generic/ConsoleDevice.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/CircularQueue.h>
+#include <AK/Vector.h>
+#include <Kernel/Devices/CharacterDevice.h>
+
+namespace Kernel {
+
+extern Spinlock<LockRank::None> g_console_lock;
+
+class ConsoleDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    static NonnullLockRefPtr<ConsoleDevice> must_create();
+
+    virtual ~ConsoleDevice() override;
+
+    // ^CharacterDevice
+    virtual bool can_read(Kernel::OpenFileDescription const&, u64) const override;
+    virtual bool can_write(Kernel::OpenFileDescription const&, u64) const override { return true; }
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer const&, size_t) override;
+    virtual StringView class_name() const override { return "Console"sv; }
+    // ^Device
+    virtual bool is_openable_by_jailed_processes() const override { return true; }
+
+    void put_char(char);
+
+    CircularQueue<char, 16384> const& logbuffer() const { return m_logbuffer; }
+
+private:
+    ConsoleDevice();
+    CircularQueue<char, 16384> m_logbuffer;
+};
+
+}

Kernel/Devices/Generic/DeviceControlDevice.cpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/DeviceControlDevice.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<DeviceControlDevice> DeviceControlDevice::must_create()
+{
+    auto device_control_device_or_error = DeviceManagement::try_create_device<DeviceControlDevice>();
+    // FIXME: Find a way to propagate errors
+    VERIFY(!device_control_device_or_error.is_error());
+    return device_control_device_or_error.release_value();
+}
+
+bool DeviceControlDevice::can_read(OpenFileDescription const&, u64) const
+{
+    return true;
+}
+
+UNMAP_AFTER_INIT DeviceControlDevice::DeviceControlDevice()
+    : CharacterDevice(2, 10)
+{
+}
+
+UNMAP_AFTER_INIT DeviceControlDevice::~DeviceControlDevice() = default;
+
+ErrorOr<size_t> DeviceControlDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+{
+    auto device_event = DeviceManagement::the().dequeue_top_device_event({});
+    if (!device_event.has_value())
+        return 0;
+
+    if (size < sizeof(DeviceEvent))
+        return Error::from_errno(EOVERFLOW);
+    size_t nread = 0;
+    TRY(buffer.write(&device_event.value(), nread, sizeof(DeviceEvent)));
+    nread += sizeof(DeviceEvent);
+    return nread;
+}
+
+ErrorOr<void> DeviceControlDevice::ioctl(OpenFileDescription&, unsigned, Userspace<void*>)
+{
+    return Error::from_errno(ENOTSUP);
+}
+
+}

Kernel/Devices/Generic/DeviceControlDevice.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/Devices/CharacterDevice.h>
+
+namespace Kernel {
+
+class DeviceControlDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    static NonnullLockRefPtr<DeviceControlDevice> must_create();
+    virtual ~DeviceControlDevice() override;
+
+private:
+    DeviceControlDevice();
+
+    // ^CharacterDevice
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override { return Error::from_errno(ENOTSUP); }
+    virtual bool can_read(OpenFileDescription const&, u64) const override;
+    virtual bool can_write(OpenFileDescription const&, u64) const override { return false; }
+    virtual StringView class_name() const override { return "DeviceControlDevice"sv; }
+};
+
+}

Kernel/Devices/Generic/FullDevice.cpp

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/API/POSIX/errno.h>
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/FullDevice.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<FullDevice> FullDevice::must_create()
+{
+    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();
+}
+
+UNMAP_AFTER_INIT FullDevice::FullDevice()
+    : CharacterDevice(1, 7)
+{
+}
+
+UNMAP_AFTER_INIT FullDevice::~FullDevice() = default;
+
+bool FullDevice::can_read(OpenFileDescription const&, u64) const
+{
+    return true;
+}
+
+ErrorOr<size_t> FullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+{
+    TRY(buffer.memset(0, size));
+    return size;
+}
+
+ErrorOr<size_t> FullDevice::write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t size)
+{
+    if (size == 0)
+        return 0;
+    return ENOSPC;
+}
+}

Kernel/Devices/Generic/FullDevice.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/Devices/CharacterDevice.h>
+
+namespace Kernel {
+
+class FullDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    static NonnullLockRefPtr<FullDevice> must_create();
+    virtual ~FullDevice() override;
+
+private:
+    FullDevice();
+
+    // ^Device
+    virtual bool is_openable_by_jailed_processes() const override { return true; }
+
+    // ^CharacterDevice
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
+    virtual bool can_read(OpenFileDescription const&, u64) const override;
+    virtual bool can_write(OpenFileDescription const&, u64) const override { return true; }
+    virtual StringView class_name() const override { return "FullDevice"sv; }
+};
+
+}

Kernel/Devices/Generic/MemoryDevice.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/MemoryDevice.h>
+#include <Kernel/Memory/AnonymousVMObject.h>
+#include <Kernel/Memory/TypedMapping.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<MemoryDevice> MemoryDevice::must_create()
+{
+    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();
+}
+
+UNMAP_AFTER_INIT MemoryDevice::MemoryDevice()
+    : CharacterDevice(1, 1)
+{
+}
+
+UNMAP_AFTER_INIT MemoryDevice::~MemoryDevice() = default;
+
+ErrorOr<size_t> MemoryDevice::read(OpenFileDescription&, u64 offset, UserOrKernelBuffer& buffer, size_t length)
+{
+    if (!MM.is_allowed_to_read_physical_memory_for_userspace(PhysicalAddress(offset), length)) {
+        dbgln_if(MEMORY_DEVICE_DEBUG, "MemoryDevice: Trying to read physical memory at {} for range of {} bytes failed due to violation of access", PhysicalAddress(offset), length);
+        return EINVAL;
+    }
+    auto mapping = TRY(Memory::map_typed<u8>(PhysicalAddress(offset), length));
+
+    auto bytes = ReadonlyBytes { mapping.ptr(), length };
+    TRY(buffer.write(bytes));
+    return length;
+}
+
+ErrorOr<NonnullLockRefPtr<Memory::VMObject>> MemoryDevice::vmobject_for_mmap(Process&, Memory::VirtualRange const& range, u64& offset, bool)
+{
+    auto viewed_address = PhysicalAddress(offset);
+
+    // Note: This check happens to guard against possible memory leak.
+    // For example, if we try to mmap physical memory from 0x1000 to 0x2000 and you
+    // can actually mmap only from 0x1001, then we would fail as usual.
+    // However, in such case if we mmap from 0x1002, we are technically not violating
+    // any rules, besides the fact that we mapped an entire page with two bytes which we
+    // were not supposed to see. To prevent that, if we use mmap(2) syscall, we should
+    // always consider the start page to be aligned on PAGE_SIZE, or to be more precise
+    // is to be set to the page base of that start address.
+    VERIFY(viewed_address == viewed_address.page_base());
+
+    if (!MM.is_allowed_to_read_physical_memory_for_userspace(viewed_address, range.size())) {
+        dbgln_if(MEMORY_DEVICE_DEBUG, "MemoryDevice: Trying to mmap physical memory at {} for range of {} bytes failed due to violation of access", viewed_address, range.size());
+        return EINVAL;
+    }
+
+    offset = 0;
+    return TRY(Memory::AnonymousVMObject::try_create_for_physical_range(viewed_address, range.size()));
+}
+
+}

Kernel/Devices/Generic/MemoryDevice.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2021, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Types.h>
+#include <Kernel/Devices/CharacterDevice.h>
+#include <Kernel/PhysicalAddress.h>
+
+namespace Kernel {
+
+class MemoryDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    static NonnullLockRefPtr<MemoryDevice> must_create();
+    ~MemoryDevice();
+
+    virtual ErrorOr<NonnullLockRefPtr<Memory::VMObject>> vmobject_for_mmap(Process&, Memory::VirtualRange const&, u64& offset, bool shared) override;
+
+private:
+    MemoryDevice();
+
+    virtual StringView class_name() const override { return "MemoryDevice"sv; }
+    virtual bool can_read(OpenFileDescription const&, u64) const override { return true; }
+    virtual bool can_write(OpenFileDescription const&, u64) const override { return false; }
+    virtual bool is_seekable() const override { return true; }
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override { return EINVAL; }
+};
+
+}

Kernel/Devices/Generic/NullDevice.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Singleton.h>
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/NullDevice.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<NullDevice> NullDevice::must_initialize()
+{
+    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()
+    : CharacterDevice(1, 3)
+{
+}
+
+UNMAP_AFTER_INIT NullDevice::~NullDevice() = default;
+
+bool NullDevice::can_read(OpenFileDescription const&, u64) const
+{
+    return true;
+}
+
+ErrorOr<size_t> NullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
+{
+    return 0;
+}
+
+ErrorOr<size_t> NullDevice::write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t buffer_size)
+{
+    return buffer_size;
+}
+
+}

Kernel/Devices/Generic/NullDevice.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/Devices/CharacterDevice.h>
+
+namespace Kernel {
+
+class NullDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    virtual ~NullDevice() override;
+
+    static NonnullLockRefPtr<NullDevice> must_initialize();
+
+private:
+    NullDevice();
+
+    // ^Device
+    virtual bool is_openable_by_jailed_processes() const override { return true; }
+
+    // ^CharacterDevice
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
+    virtual bool can_write(OpenFileDescription const&, u64) const override { return true; }
+    virtual bool can_read(OpenFileDescription const&, u64) const override;
+    virtual StringView class_name() const override { return "NullDevice"sv; }
+    virtual bool is_seekable() const override { return true; }
+};
+
+}

Kernel/Devices/Generic/RandomDevice.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/RandomDevice.h>
+#include <Kernel/Random.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<RandomDevice> RandomDevice::must_create()
+{
+    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();
+}
+
+UNMAP_AFTER_INIT RandomDevice::RandomDevice()
+    : CharacterDevice(1, 8)
+{
+}
+
+UNMAP_AFTER_INIT RandomDevice::~RandomDevice() = default;
+
+bool RandomDevice::can_read(OpenFileDescription const&, u64) const
+{
+    return true;
+}
+
+ErrorOr<size_t> RandomDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+{
+    return buffer.write_buffered<256>(size, [&](Bytes bytes) {
+        get_good_random_bytes(bytes);
+        return bytes.size();
+    });
+}
+
+ErrorOr<size_t> RandomDevice::write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t size)
+{
+    // FIXME: Use input for entropy? I guess that could be a neat feature?
+    return size;
+}
+
+}

Kernel/Devices/Generic/RandomDevice.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/Devices/CharacterDevice.h>
+
+namespace Kernel {
+
+class RandomDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    static NonnullLockRefPtr<RandomDevice> must_create();
+    virtual ~RandomDevice() override;
+
+private:
+    RandomDevice();
+
+    // ^Device
+    virtual bool is_openable_by_jailed_processes() const override { return true; }
+
+    // ^CharacterDevice
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
+    virtual bool can_read(OpenFileDescription const&, u64) const override;
+    virtual bool can_write(OpenFileDescription const&, u64) const override { return true; }
+    virtual StringView class_name() const override { return "RandomDevice"sv; }
+};
+
+}

Kernel/Devices/Generic/SelfTTYDevice.cpp

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/SelfTTYDevice.h>
+#include <Kernel/Sections.h>
+#include <Kernel/TTY/TTY.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<SelfTTYDevice> SelfTTYDevice::must_create()
+{
+    auto self_tty_device_or_error = DeviceManagement::try_create_device<SelfTTYDevice>();
+    // FIXME: Find a way to propagate errors
+    VERIFY(!self_tty_device_or_error.is_error());
+    return self_tty_device_or_error.release_value();
+}
+
+ErrorOr<NonnullRefPtr<OpenFileDescription>> SelfTTYDevice::open(int options)
+{
+    // Note: If for some odd reason we try to open this device (early on boot?)
+    // while there's no current Process assigned, don't fail and return an error.
+    if (!Process::has_current())
+        return Error::from_errno(ESRCH);
+    auto& current_process = Process::current();
+    auto tty = current_process.tty();
+    if (!tty)
+        return Error::from_errno(ENXIO);
+    auto description = TRY(OpenFileDescription::try_create(*tty));
+    description->set_rw_mode(options);
+    description->set_file_flags(options);
+    return description;
+}
+
+bool SelfTTYDevice::can_read(OpenFileDescription const&, u64) const
+{
+    VERIFY_NOT_REACHED();
+}
+
+bool SelfTTYDevice::can_write(OpenFileDescription const&, u64) const
+{
+    VERIFY_NOT_REACHED();
+}
+
+ErrorOr<size_t> SelfTTYDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
+{
+    VERIFY_NOT_REACHED();
+}
+
+ErrorOr<size_t> SelfTTYDevice::write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t)
+{
+    VERIFY_NOT_REACHED();
+}
+
+UNMAP_AFTER_INIT SelfTTYDevice::SelfTTYDevice()
+    : CharacterDevice(5, 0)
+{
+}
+
+UNMAP_AFTER_INIT SelfTTYDevice::~SelfTTYDevice()
+{
+}
+
+}

Kernel/Devices/Generic/SelfTTYDevice.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/Devices/CharacterDevice.h>
+
+namespace Kernel {
+
+class SelfTTYDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    static NonnullLockRefPtr<SelfTTYDevice> must_create();
+    virtual ~SelfTTYDevice() override;
+
+private:
+    SelfTTYDevice();
+
+    // ^Device
+    virtual bool is_openable_by_jailed_processes() const override { return true; }
+
+    // ^CharacterDevice
+    virtual ErrorOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
+    virtual bool can_read(OpenFileDescription const&, u64) const override;
+    virtual bool can_write(OpenFileDescription const&, u64) const override;
+    virtual StringView class_name() const override { return "SelfTTYDevice"sv; }
+};
+
+}

Kernel/Devices/Generic/ZeroDevice.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <Kernel/Devices/DeviceManagement.h>
+#include <Kernel/Devices/Generic/ZeroDevice.h>
+#include <Kernel/Sections.h>
+
+namespace Kernel {
+
+UNMAP_AFTER_INIT NonnullLockRefPtr<ZeroDevice> ZeroDevice::must_create()
+{
+    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();
+}
+
+UNMAP_AFTER_INIT ZeroDevice::ZeroDevice()
+    : CharacterDevice(1, 5)
+{
+}
+
+UNMAP_AFTER_INIT ZeroDevice::~ZeroDevice() = default;
+
+bool ZeroDevice::can_read(OpenFileDescription const&, u64) const
+{
+    return true;
+}
+
+ErrorOr<size_t> ZeroDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+{
+    TRY(buffer.memset(0, size));
+    return size;
+}
+
+ErrorOr<size_t> ZeroDevice::write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t size)
+{
+    return size;
+}
+
+}

Kernel/Devices/Generic/ZeroDevice.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <Kernel/Devices/CharacterDevice.h>
+
+namespace Kernel {
+
+class ZeroDevice final : public CharacterDevice {
+    friend class DeviceManagement;
+
+public:
+    static NonnullLockRefPtr<ZeroDevice> must_create();
+    virtual ~ZeroDevice() override;
+
+private:
+    ZeroDevice();
+
+    // ^Device
+    virtual bool is_openable_by_jailed_processes() const override { return true; }
+
+    // ^CharacterDevice
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
+    virtual bool can_read(OpenFileDescription const&, u64) const override;
+    virtual bool can_write(OpenFileDescription const&, u64) const override { return true; }
+    virtual StringView class_name() const override { return "ZeroDevice"sv; }
+};
+
+}