Sinipelto/banan-os
1
0
Fork 0
forked from Bananymous/banan-os
Code Pull Requests Activity

Kernel: Add common {read,write}_blocks() api to BlockDevice

Browse Source
This commit is contained in:
Bananymous
2023-11-21 15:19:07 +02:00
parent 6a068fb9f9
commit b749963b62
5 changed files with 42 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
kernel/kernel/Storage/Partition.cpp
View File

@@ -5,21 +5,21 @@
namespace Kernel
{
BAN::ErrorOr<BAN::RefPtr<Partition>> Partition::create(BAN::RefPtr<BlockDevice> device, const BAN::GUID& type, const BAN::GUID& guid, uint64_t first_sector, uint64_t last_sector, uint64_t attr, const char* label, uint32_t index)
BAN::ErrorOr<BAN::RefPtr<Partition>> Partition::create(BAN::RefPtr<BlockDevice> device, const BAN::GUID& type, const BAN::GUID& guid, uint64_t first_block, uint64_t last_block, uint64_t attr, const char* label, uint32_t index)
{
auto partition_ptr = new Partition(device, type, guid, first_sector, last_sector, attr, label, index);
auto partition_ptr = new Partition(device, type, guid, first_block, last_block, attr, label, index);
if (partition_ptr == nullptr)
return BAN::Error::from_errno(ENOMEM);
return BAN::RefPtr<Partition>::adopt(partition_ptr);
}
Partition::Partition(BAN::RefPtr<BlockDevice> device, const BAN::GUID& type, const BAN::GUID& guid, uint64_t first_sector, uint64_t last_sector, uint64_t attr, const char* label, uint32_t index)
Partition::Partition(BAN::RefPtr<BlockDevice> device, const BAN::GUID& type, const BAN::GUID& guid, uint64_t first_block, uint64_t last_block, uint64_t attr, const char* label, uint32_t index)
: BlockDevice(0660, 0, 0)
, m_device(device)
, m_type(type)
, m_guid(guid)
, m_first_sector(first_sector)
, m_last_sector(last_sector)
, m_first_block(first_block)
, m_last_block(last_block)
, m_attributes(attr)
, m_name(BAN::String::formatted("{}{}", device->name(), index))
, m_rdev(makedev(major(device->rdev()), index))
@@ -27,23 +27,23 @@ namespace Kernel
memcpy(m_label, label, sizeof(m_label));
}
BAN::ErrorOr<void> Partition::read_sectors(uint64_t first_sector, size_t sector_count, BAN::ByteSpan buffer)
BAN::ErrorOr<void> Partition::read_blocks(uint64_t first_block, size_t block_count, BAN::ByteSpan buffer)
{
ASSERT(buffer.size() >= sector_count * m_device->blksize());
const uint32_t sectors_in_partition = m_last_sector - m_first_sector + 1;
if (first_sector + sector_count > sectors_in_partition)
ASSERT(buffer.size() >= block_count * m_device->blksize());
const uint32_t blocks_in_partition = m_last_block - m_first_block + 1;
if (first_block + block_count > blocks_in_partition)
return BAN::Error::from_error_code(ErrorCode::Storage_Boundaries);
TRY(m_device->read_sectors(m_first_sector + first_sector, sector_count, buffer));
TRY(m_device->read_blocks(m_first_block + first_block, block_count, buffer));
return {};
}
BAN::ErrorOr<void> Partition::write_sectors(uint64_t first_sector, size_t sector_count, BAN::ConstByteSpan buffer)
BAN::ErrorOr<void> Partition::write_blocks(uint64_t first_block, size_t block_count, BAN::ConstByteSpan buffer)
{
ASSERT(buffer.size() >= sector_count * m_device->blksize());
const uint32_t sectors_in_partition = m_last_sector - m_first_sector + 1;
if (m_first_sector + sector_count > sectors_in_partition)
ASSERT(buffer.size() >= block_count * m_device->blksize());
const uint32_t blocks_in_partition = m_last_block - m_first_block + 1;
if (m_first_block + block_count > blocks_in_partition)
return BAN::Error::from_error_code(ErrorCode::Storage_Boundaries);
TRY(m_device->write_sectors(m_first_sector + first_sector, sector_count, buffer));
TRY(m_device->write_blocks(m_first_block + first_block, block_count, buffer));
return {};
}
@@ -54,17 +54,17 @@ namespace Kernel
if (offset % m_device->blksize() || buffer.size() % m_device->blksize())
return BAN::Error::from_errno(ENOTSUP);
const uint32_t sectors_in_partition = m_last_sector - m_first_sector + 1;
uint32_t first_sector = offset / m_device->blksize();
uint32_t sector_count = buffer.size() / m_device->blksize();
const uint32_t blocks_in_partition = m_last_block - m_first_block + 1;
uint32_t first_block = offset / m_device->blksize();
uint32_t block_count = buffer.size() / m_device->blksize();
if (first_sector >= sectors_in_partition)
if (first_block >= blocks_in_partition)
return 0;
if (first_sector + sector_count > sectors_in_partition)
sector_count = sectors_in_partition - first_sector;
if (first_block + block_count > blocks_in_partition)
block_count = blocks_in_partition - first_block;
TRY(read_sectors(first_sector, sector_count, buffer));
return sector_count * m_device->blksize();
TRY(read_blocks(first_block, block_count, buffer));
return block_count * m_device->blksize();
}
}