mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 11:18:11 +00:00
11eee67b85
Until now, our kernel has reimplemented a number of AK classes to provide automatic internal locking: - RefPtr - NonnullRefPtr - WeakPtr - Weakable This patch renames the Kernel classes so that they can coexist with the original AK classes: - RefPtr => LockRefPtr - NonnullRefPtr => NonnullLockRefPtr - WeakPtr => LockWeakPtr - Weakable => LockWeakable The goal here is to eventually get rid of the Lock* classes in favor of using external locking.
45 lines
2.2 KiB
C++
45 lines
2.2 KiB
C++
/*
|
|
* Copyright (c) 2021, Pankaj R <pankydev8@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "NVMeNameSpace.h"
|
|
#include <AK/NonnullOwnPtr.h>
|
|
#include <Kernel/Devices/DeviceManagement.h>
|
|
#include <Kernel/Storage/NVMe/NVMeController.h>
|
|
#include <Kernel/Storage/StorageManagement.h>
|
|
|
|
namespace Kernel {
|
|
|
|
UNMAP_AFTER_INIT ErrorOr<NonnullLockRefPtr<NVMeNameSpace>> NVMeNameSpace::try_create(NVMeController const& controller, NonnullLockRefPtrVector<NVMeQueue> queues, u8 controller_id, u16 nsid, size_t storage_size, size_t lba_size)
|
|
{
|
|
auto minor_number = StorageManagement::generate_storage_minor_number();
|
|
auto major_number = StorageManagement::storage_type_major_number();
|
|
auto device_name_kstring = TRY(KString::formatted("nvme{:d}n{:d}", controller_id, nsid));
|
|
auto device = TRY(DeviceManagement::try_create_device<NVMeNameSpace>(StorageDevice::LUNAddress { controller.controller_id(), nsid, 0 }, move(queues), storage_size, lba_size, major_number.value(), minor_number.value(), nsid, move(device_name_kstring)));
|
|
return device;
|
|
}
|
|
|
|
UNMAP_AFTER_INIT NVMeNameSpace::NVMeNameSpace(LUNAddress logical_unit_number_address, NonnullLockRefPtrVector<NVMeQueue> queues, size_t max_addresable_block, size_t lba_size, size_t major_number, size_t minor_number, u16 nsid, NonnullOwnPtr<KString> dev_name)
|
|
: StorageDevice(logical_unit_number_address, major_number, minor_number, lba_size, max_addresable_block, move(dev_name))
|
|
, m_nsid(nsid)
|
|
, m_queues(move(queues))
|
|
{
|
|
}
|
|
|
|
void NVMeNameSpace::start_request(AsyncBlockDeviceRequest& request)
|
|
{
|
|
auto index = Processor::current_id();
|
|
auto& queue = m_queues.at(index);
|
|
// TODO: For now we support only IO transfers of size PAGE_SIZE (Going along with the current constraint in the block layer)
|
|
// Eventually remove this constraint by using the PRP2 field in the submission struct and remove block layer constraint for NVMe driver.
|
|
VERIFY(request.block_count() <= (PAGE_SIZE / block_size()));
|
|
|
|
if (request.request_type() == AsyncBlockDeviceRequest::Read) {
|
|
queue.read(request, m_nsid, request.block_index(), request.block_count());
|
|
} else {
|
|
queue.write(request, m_nsid, request.block_index(), request.block_count());
|
|
}
|
|
}
|
|
}
|