system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-23 02:55:15 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity
serenity/Kernel/Devices/Device.cpp

87 lines
2.4 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 08:38:21 +00:00
*/
Kernel: Switch singletons to use new Singleton class MemoryManager cannot use the Singleton class because MemoryManager::initialize is called before the global constructors are run. That caused the Singleton to be re-initialized, causing it to create another MemoryManager instance. Fixes #3226
2020-08-25 01:35:19 +00:00
#include <AK/Singleton.h>
Kernel: Make FIFO inherit from File.
2019-04-29 02:55:54 +00:00
#include <Kernel/Devices/Device.h>
Kernel: Introduce the DeviceManagement singleton 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.
2021-09-11 06:19:20 +00:00
#include <Kernel/Devices/DeviceManagement.h>
Revert "Kernel: Replace IRQHandler with the new InterruptHandler class" This reverts commit 6c72736b26a81a8f03d8dd47989bfffe26bb1c95. I am unable to boot on my home machine with this change in the tree.
2020-01-22 21:23:50 +00:00
#include <Kernel/FileSystem/InodeMetadata.h>
Kernel: Split the SysFS core files into smaller components
2022-10-23 18:51:56 +00:00
#include <Kernel/FileSystem/SysFS/Component.h>
Kernel/SysFS: Reduce the responsibilities of the Registry object Instead, let the /sys/dev/block and /sys/dev/char directories to handle the registering part of SysFSDeviceComponents by themselves.
2022-04-22 21:26:36 +00:00
#include <Kernel/FileSystem/SysFS/Subsystems/DeviceIdentifiers/BlockDevicesDirectory.h>
#include <Kernel/FileSystem/SysFS/Subsystems/DeviceIdentifiers/CharacterDevicesDirectory.h>
Kernel/Devices: Ensure appropriate locking on the Device map singleton Devices might be removed and inserted at anytime, so let's ensure we always do these kind of operations with a good known state of the HashMap. The VirtIO code was modified to create devices outside the IRQ handler, so now it works with the new locking of the devices singleton, but a better approach might be needed later on.
2021-08-14 07:13:27 +00:00
#include <Kernel/Sections.h>
Kernel: Add Device base class for CharacterDevice. ..to prepare for adding a BlockDevice class.
2019-02-15 23:47:20 +00:00
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
namespace Kernel {
Kernel: Make major and minor numbers to be DistinctNumerics This helps avoid confusion in general, and make constructors, methods and code patterns much more clean and understandable.
2021-12-23 18:08:18 +00:00
Device::Device(MajorNumber major, MinorNumber minor)
Kernel: Run clang-format on everything.
2019-06-07 09:43:58 +00:00
: m_major(major)
, m_minor(minor)
Kernel: Have devices automagically register themselves with the VFS.
2019-02-17 09:38:07 +00:00
{
Kernel/Devices: Defer creation of SysFS component after the constructor Instead of doing so in the constructor, let's do immediately after the constructor, so we can safely pass a reference of a Device, so the SysFSDeviceComponent constructor can use that object to identify whether it's a block device or a character device. This allows to us to not hold a device in SysFSDeviceComponent with a RefPtr. Also, we also call the before_removing method in both SlavePTY::unref and File::unref, so because Device has that method being overrided, it can ensure the device is removed always cleanly.
2021-09-10 11:44:46 +00:00
}
Kernel/Devices: Add two protected methods for DeviceManagement functions These methods are essentially splitted from the after_inserting method and the will_be_destroyed method so later on we can allow Storage devices to override the after_inserting method and the will_be_destroyed method while still being able to use shared functionality as before, such as adding the device to and removing it from the device list.
2022-04-23 08:19:02 +00:00
void Device::before_will_be_destroyed_remove_from_device_management()
{
DeviceManagement::the().before_device_removal({}, *this);
m_state = State::BeingRemoved;
}
void Device::after_inserting_add_to_device_management()
Kernel/Devices: Defer creation of SysFS component after the constructor Instead of doing so in the constructor, let's do immediately after the constructor, so we can safely pass a reference of a Device, so the SysFSDeviceComponent constructor can use that object to identify whether it's a block device or a character device. This allows to us to not hold a device in SysFSDeviceComponent with a RefPtr. Also, we also call the before_removing method in both SlavePTY::unref and File::unref, so because Device has that method being overrided, it can ensure the device is removed always cleanly.
2021-09-10 11:44:46 +00:00
{
Kernel: Introduce the DeviceManagement singleton 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.
2021-09-11 06:19:20 +00:00
DeviceManagement::the().after_inserting_device({}, *this);
Kernel/Devices: Add two protected methods for DeviceManagement functions These methods are essentially splitted from the after_inserting method and the will_be_destroyed method so later on we can allow Storage devices to override the after_inserting method and the will_be_destroyed method while still being able to use shared functionality as before, such as adding the device to and removing it from the device list.
2022-04-23 08:19:02 +00:00
}
Kernel: Make Device::after_inserting to return ErrorOr<void> Instead of just returning nothing, let's return Error or nothing. This would help later on with error propagation in case of failure during this method. This also makes us more paranoid about failure in this method, so when initializing a DisplayConnector we safely tear down the internal members of the object. This applies the same for a StorageDevice object, but its after_inserting method is much smaller compared to the DisplayConnector overriden method.
2022-12-21 20:33:56 +00:00
ErrorOr<void> Device::after_inserting()
Kernel/Devices: Add two protected methods for DeviceManagement functions These methods are essentially splitted from the after_inserting method and the will_be_destroyed method so later on we can allow Storage devices to override the after_inserting method and the will_be_destroyed method while still being able to use shared functionality as before, such as adding the device to and removing it from the device list.
2022-04-23 08:19:02 +00:00
{
Kernel/Devices: Defer creation of SysFS component after the constructor Instead of doing so in the constructor, let's do immediately after the constructor, so we can safely pass a reference of a Device, so the SysFSDeviceComponent constructor can use that object to identify whether it's a block device or a character device. This allows to us to not hold a device in SysFSDeviceComponent with a RefPtr. Also, we also call the before_removing method in both SlavePTY::unref and File::unref, so because Device has that method being overrided, it can ensure the device is removed always cleanly.
2021-09-10 11:44:46 +00:00
VERIFY(!m_sysfs_component);
Kernel: Expose device presence in /sys/dev/char and /sys/dev/block These files are not marked as block devices or character devices so they are not meant to be used as device nodes. The filenames are formatted to the pattern "major:minor", but a Userland program need to call the parse these format and inspect the the major and minor numbers and create the real device nodes in /dev. Later on, it might be a good idea to ensure we don't create new SysFSComponents on the heap for each Device, but rather generate them only when required (and preferably to not create a SysFSComponent at all if possible).
2021-08-14 08:40:37 +00:00
auto sys_fs_component = SysFSDeviceComponent::must_create(*this);
m_sysfs_component = sys_fs_component;
Kernel/Devices: Abstract SysFS Device add/remove methods more properly It is starting to get a little messy with how each device can try to add or remove itself to either /sys/dev/block or /sys/dev/char directories. To better do this, we introduce 4 virtual methods to take care of that, so until we ensure all nodes in /sys/dev/block and /sys/dev/char are actual symlinks, we allow the Device base class to call virtual methods upon insertion or before being destroying, so it add itself elegantly to either of these directories or remove itself when needed. For special cases where we need to create symlinks, we have two virtual methods to be called otherwise to do almost the same thing mentioned before, but to use symlinks instead.
2022-07-16 07:39:57 +00:00
after_inserting_add_to_device_identifier_directory();
Kernel: Get rid of *LockRefPtr in the SysFS filesystem code To do this we also need to get rid of LockRefPtrs in the USB code as well. Most of the SysFS nodes are statically generated during boot and are not mutated afterwards. The same goes for general device code - once we generate the appropriate SysFS nodes, we almost never mutate the node pointers afterwards, making locking unnecessary.
2023-04-05 10:21:11 +00:00
after_inserting_add_to_device_management();
Kernel: Make Device::after_inserting to return ErrorOr<void> Instead of just returning nothing, let's return Error or nothing. This would help later on with error propagation in case of failure during this method. This also makes us more paranoid about failure in this method, so when initializing a DisplayConnector we safely tear down the internal members of the object. This applies the same for a StorageDevice object, but its after_inserting method is much smaller compared to the DisplayConnector overriden method.
2022-12-21 20:33:56 +00:00
return {};
Kernel: Expose device presence in /sys/dev/char and /sys/dev/block These files are not marked as block devices or character devices so they are not meant to be used as device nodes. The filenames are formatted to the pattern "major:minor", but a Userland program need to call the parse these format and inspect the the major and minor numbers and create the real device nodes in /dev. Later on, it might be a good idea to ensure we don't create new SysFSComponents on the heap for each Device, but rather generate them only when required (and preferably to not create a SysFSComponent at all if possible).
2021-08-14 08:40:37 +00:00
}
Kernel: Rename File::{before_removing => will_be_destroyed} This will allow File and it's descendants to use RefCounted instead of having a custom implementation of unref. (Since RefCounted calls will_be_destroyed automatically) This commit also removes an erroneous call to `before_removing` in AHCIPort, this is a duplicate call, as the only reference to the device is immediately dropped following the call, which in turns calls `before_removing` via File::unref.
2021-12-28 23:00:29 +00:00
void Device::will_be_destroyed()
Kernel: Expose device presence in /sys/dev/char and /sys/dev/block These files are not marked as block devices or character devices so they are not meant to be used as device nodes. The filenames are formatted to the pattern "major:minor", but a Userland program need to call the parse these format and inspect the the major and minor numbers and create the real device nodes in /dev. Later on, it might be a good idea to ensure we don't create new SysFSComponents on the heap for each Device, but rather generate them only when required (and preferably to not create a SysFSComponent at all if possible).
2021-08-14 08:40:37 +00:00
{
Kernel/Devices: Defer creation of SysFS component after the constructor Instead of doing so in the constructor, let's do immediately after the constructor, so we can safely pass a reference of a Device, so the SysFSDeviceComponent constructor can use that object to identify whether it's a block device or a character device. This allows to us to not hold a device in SysFSDeviceComponent with a RefPtr. Also, we also call the before_removing method in both SlavePTY::unref and File::unref, so because Device has that method being overrided, it can ensure the device is removed always cleanly.
2021-09-10 11:44:46 +00:00
VERIFY(m_sysfs_component);
Kernel/Devices: Add two protected methods for DeviceManagement functions These methods are essentially splitted from the after_inserting method and the will_be_destroyed method so later on we can allow Storage devices to override the after_inserting method and the will_be_destroyed method while still being able to use shared functionality as before, such as adding the device to and removing it from the device list.
2022-04-23 08:19:02 +00:00
before_will_be_destroyed_remove_from_device_management();
Kernel: Get rid of *LockRefPtr in the SysFS filesystem code To do this we also need to get rid of LockRefPtrs in the USB code as well. Most of the SysFS nodes are statically generated during boot and are not mutated afterwards. The same goes for general device code - once we generate the appropriate SysFS nodes, we almost never mutate the node pointers afterwards, making locking unnecessary.
2023-04-05 10:21:11 +00:00
before_will_be_destroyed_remove_from_device_identifier_directory();
Kernel: Have devices automagically register themselves with the VFS.
2019-02-17 09:38:07 +00:00
}
Kernel: Add Device base class for CharacterDevice. ..to prepare for adding a BlockDevice class.
2019-02-15 23:47:20 +00:00
Device::~Device()
{
Kernel: Expose device presence in /sys/dev/char and /sys/dev/block These files are not marked as block devices or character devices so they are not meant to be used as device nodes. The filenames are formatted to the pattern "major:minor", but a Userland program need to call the parse these format and inspect the the major and minor numbers and create the real device nodes in /dev. Later on, it might be a good idea to ensure we don't create new SysFSComponents on the heap for each Device, but rather generate them only when required (and preferably to not create a SysFSComponent at all if possible).
2021-08-14 08:40:37 +00:00
VERIFY(m_state == State::BeingRemoved);
Kernel: Add Device base class for CharacterDevice. ..to prepare for adding a BlockDevice class.
2019-02-15 23:47:20 +00:00
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
ErrorOr<NonnullOwnPtr<KString>> Device::pseudo_path(OpenFileDescription const&) const
Kernel: Add Device base class for CharacterDevice. ..to prepare for adding a BlockDevice class.
2019-02-15 23:47:20 +00:00
{
Kernel: Handle string format errors in Device::pseudo_path(..) :^)
2021-11-29 11:03:33 +00:00
return KString::formatted("device:{},{}", major(), minor());
Kernel: Expose info about source devices of mounts in /proc/df
2019-08-17 09:17:36 +00:00
}
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
Kernel: Use non-locking {Nonnull,}RefPtr for OpenFileDescription This patch switches away from {Nonnull,}LockRefPtr to the non-locking smart pointers throughout the kernel. I've looked at the handful of places where these were being persisted and I don't see any race situations. Note that the process file descriptor table (Process::m_fds) was already guarded via MutexProtected.
2023-03-06 18:29:25 +00:00
ErrorOr<NonnullRefPtr<OpenFileDescription>> Device::open(int options)
Kernel: Allow opening some device nodes sparingly for jailed processes From now on, we don't allow jailed processes to open all device nodes in /dev, but only allow jailed processes to open /dev/full, /dev/zero, /dev/null, and various TTY and PTY devices (and not including virtual consoles) so we basically restrict applications to what they can do when they are in jail. The motivation for this type of restriction is to ensure that even if a remote code execution occurred, the damage that can be done is very small. We also don't restrict reading and writing on device nodes that were already opened, because that limit seems not useful, especially in the case where we do want to provide an OpenFileDescription to such device but nothing further than that.
2022-12-02 09:33:57 +00:00
{
Kernel: Mark Process::jail() method as const We really don't want callers of this function to accidentally change the jail, or even worse - remove the Process from an attached jail. To ensure this never happens, we can just declare this method as const so nobody can mutate it this way.
2023-01-06 08:08:22 +00:00
TRY(Process::current().jail().with([&](auto const& my_jail) -> ErrorOr<void> {
Kernel: Allow opening some device nodes sparingly for jailed processes From now on, we don't allow jailed processes to open all device nodes in /dev, but only allow jailed processes to open /dev/full, /dev/zero, /dev/null, and various TTY and PTY devices (and not including virtual consoles) so we basically restrict applications to what they can do when they are in jail. The motivation for this type of restriction is to ensure that even if a remote code execution occurred, the damage that can be done is very small. We also don't restrict reading and writing on device nodes that were already opened, because that limit seems not useful, especially in the case where we do want to provide an OpenFileDescription to such device but nothing further than that.
2022-12-02 09:33:57 +00:00
if (my_jail && !is_openable_by_jailed_processes())
return Error::from_errno(EPERM);
return {};
}));
return File::open(options);
}
Everywhere: Run clang-format
2022-04-01 17:58:27 +00:00
void Device::process_next_queued_request(Badge<AsyncDeviceRequest>, AsyncDeviceRequest const& completed_request)
Kernel: Implement an asynchronous device request stack This allows issuing asynchronous requests for devices and waiting on the completion of the request. The requests can cascade into multiple sub-requests. Since IRQs may complete at any time, if the current process is no longer the same that started the process, we need to swich the paging context before accessing user buffers. Change the PATA driver to use this model.
2020-11-02 18:16:01 +00:00
{
Kernel: Rename ScopedSpinlock => SpinlockLocker This matches MutexLocker, and doesn't sound like it's a lock itself.
2021-08-21 23:49:22 +00:00
SpinlockLocker lock(m_requests_lock);
Kernel: Fix race conditions processing async device requests
2021-02-06 23:59:32 +00:00
VERIFY(!m_requests.is_empty());
VERIFY(m_requests.first().ptr() == &completed_request);
m_requests.remove(m_requests.begin());
if (!m_requests.is_empty()) {
auto* next_request = m_requests.first().ptr();
next_request->do_start(move(lock));
Kernel: Implement an asynchronous device request stack This allows issuing asynchronous requests for devices and waiting on the completion of the request. The requests can cascade into multiple sub-requests. Since IRQs may complete at any time, if the current process is no longer the same that started the process, we need to swich the paging context before accessing user buffers. Change the PATA driver to use this model.
2020-11-02 18:16:01 +00:00
}
Kernel: Move block condition evaluation out of the Scheduler This makes the Scheduler a lot leaner by not having to evaluate block conditions every time it is invoked. Instead evaluate them as the states change, and unblock threads at that point. This also implements some more waitid/waitpid/wait features and behavior. For example, WUNTRACED and WNOWAIT are now supported. And wait will now not return EINTR when SIGCHLD is delivered at the same time.
2020-11-29 23:05:27 +00:00
evaluate_block_conditions();
Kernel: Implement an asynchronous device request stack This allows issuing asynchronous requests for devices and waiting on the completion of the request. The requests can cascade into multiple sub-requests. Since IRQs may complete at any time, if the current process is no longer the same that started the process, we need to swich the paging context before accessing user buffers. Change the PATA driver to use this model.
2020-11-02 18:16:01 +00:00
}
Kernel: Move all code into the Kernel namespace
2020-02-16 00:27:42 +00:00
}
Reference in a new issue Copy permalink