mirror of
https://github.com/RGBCube/serenity
synced 2025-05-20 14:15:07 +00:00
741c871bc1
There's basically no real difference in software between a SATA harddisk and IDE harddisk. The difference in the implementation is for the host bus adapter protocol and registers layout. Therefore, there's no point in putting a distinction in software to these devices. This change also greatly simplifies and removes stale APIs and removes unnecessary parameters in constructor calls, which tighten things further everywhere.
68 lines
2.3 KiB
C++
68 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/RamdiskController.h>
|
|
#include <Kernel/Storage/RamdiskDevice.h>
|
|
|
|
namespace Kernel {
|
|
|
|
NonnullRefPtr<RamdiskDevice> RamdiskDevice::create(const RamdiskController& 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;
|
|
// FIXME: We need a way of formatting strings with KString!
|
|
auto device_name = String::formatted("ramdisk{}", drive_index);
|
|
auto device_name_kstring = KString::must_create(device_name.view());
|
|
|
|
auto device_or_error = DeviceManagement::try_create_device<RamdiskDevice>(controller, move(region), major, minor, move(device_name_kstring));
|
|
// FIXME: Find a way to propagate errors
|
|
VERIFY(!device_or_error.is_error());
|
|
return device_or_error.release_value();
|
|
}
|
|
|
|
RamdiskDevice::RamdiskDevice(const RamdiskController&, NonnullOwnPtr<Memory::Region>&& region, int major, int minor, NonnullOwnPtr<KString> device_name)
|
|
: StorageDevice(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()
|
|
{
|
|
}
|
|
|
|
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() * 512;
|
|
size_t length = request.block_count() * 512;
|
|
|
|
if ((offset + length > base + size) || (offset + length < base)) {
|
|
request.complete(AsyncDeviceRequest::Failure);
|
|
} else {
|
|
auto result = KResult(KSuccess);
|
|
if (request.request_type() == AsyncBlockDeviceRequest::Read) {
|
|
result = request.buffer().write(offset, length);
|
|
} else {
|
|
result = request.buffer().read(offset, length);
|
|
}
|
|
request.complete(result.is_success() ? AsyncDeviceRequest::Success : AsyncDeviceRequest::MemoryFault);
|
|
}
|
|
}
|
|
|
|
}
|