mirror of
https://github.com/RGBCube/serenity
synced 2025-05-19 20:35:06 +00:00
4744ccbff0
LUN address is essentially how people used to address SCSI devices back in the day we had these devices more in use. However, SCSI was taken as an abstraction layer for many Unix and Unix-like systems, so it still common to see LUN addresses in use. In Serenity, we don't really provide such abstraction layer, and therefore until now, we didn't use LUNs too. However (again), this changes, as we want to let users to address their devices under SysFS easily. LUNs make sense in that regard, because they can be easily adapted to different interfaces besides SCSI. For example, for legacy ATA hard drive being connected to the first IDE controller which was enumerated on the PCI bus, and then to the primary channel as slave device, the LUN address would be 0:0:1. To make this happen, we add unique ID number to each StorageController, which increments by 1 for each new instance of StorageController. Then, we adapt the ATA and NVMe devices to use these numbers and generate LUN in the construction time.
64 lines
2.3 KiB
C++
64 lines
2.3 KiB
C++
/*
|
|
* Copyright (c) 2021, the SerenityOS developers.
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/Memory.h>
|
|
#include <AK/StringView.h>
|
|
#include <Kernel/Devices/DeviceManagement.h>
|
|
#include <Kernel/FileSystem/OpenFileDescription.h>
|
|
#include <Kernel/Storage/Ramdisk/Controller.h>
|
|
#include <Kernel/Storage/Ramdisk/Device.h>
|
|
|
|
namespace Kernel {
|
|
|
|
NonnullRefPtr<RamdiskDevice> RamdiskDevice::create(RamdiskController const& controller, NonnullOwnPtr<Memory::Region>&& region, int major, int minor)
|
|
{
|
|
// FIXME: Try to not hardcode a maximum of 16 partitions per drive!
|
|
size_t drive_index = minor / 16;
|
|
auto device_name = MUST(KString::formatted("ramdisk{}", drive_index));
|
|
|
|
auto device_or_error = DeviceManagement::try_create_device<RamdiskDevice>(controller, move(region), major, minor, move(device_name));
|
|
// FIXME: Find a way to propagate errors
|
|
VERIFY(!device_or_error.is_error());
|
|
return device_or_error.release_value();
|
|
}
|
|
|
|
RamdiskDevice::RamdiskDevice(RamdiskController const& controller, NonnullOwnPtr<Memory::Region>&& region, int major, int minor, NonnullOwnPtr<KString> device_name)
|
|
: StorageDevice(LUNAddress { controller.controller_id(), 0, 0 }, major, minor, 512, region->size() / 512, move(device_name))
|
|
, m_region(move(region))
|
|
{
|
|
dmesgln("Ramdisk: Device #{} @ {}, Capacity={}", minor, m_region->vaddr(), max_addressable_block() * 512);
|
|
}
|
|
|
|
RamdiskDevice::~RamdiskDevice() = default;
|
|
|
|
StringView RamdiskDevice::class_name() const
|
|
{
|
|
return "RamdiskDevice"sv;
|
|
}
|
|
|
|
void RamdiskDevice::start_request(AsyncBlockDeviceRequest& request)
|
|
{
|
|
MutexLocker locker(m_lock);
|
|
|
|
u8* base = m_region->vaddr().as_ptr();
|
|
size_t size = m_region->size();
|
|
u8* offset = base + request.block_index() * request.block_size();
|
|
size_t length = request.buffer_size();
|
|
|
|
if ((offset + length > base + size) || (offset + length < base)) {
|
|
request.complete(AsyncDeviceRequest::Failure);
|
|
} else {
|
|
ErrorOr<void> result;
|
|
if (request.request_type() == AsyncBlockDeviceRequest::Read) {
|
|
result = request.buffer().write(offset, length);
|
|
} else {
|
|
result = request.buffer().read(offset, length);
|
|
}
|
|
request.complete(!result.is_error() ? AsyncDeviceRequest::Success : AsyncDeviceRequest::MemoryFault);
|
|
}
|
|
}
|
|
|
|
}
|