1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 02:37:36 +00:00

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

This commit is contained in:
Liav A 2023-03-18 13:17:13 +02:00 committed by Jelle Raaijmakers
parent 9eeda5719e
commit 4617c05a08
27 changed files with 34 additions and 34 deletions

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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