RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 08:58:11 +00:00
Code Issues Activity Actions

LibPartition: Make GUIDPartitionTable kernel/userland agnostic

Browse source
This commit is contained in:
Samuel Bowman 2022-06-15 22:57:05 -04:00 • committed by Linus Groh
parent 11b4d51fc9
commit 380ce43afc
2 changed files with 42 additions and 11 deletions
Download patch file Download diff file Expand all files Collapse all files

43
Userland/Libraries/LibPartition/GUIDPartitionTable.cpp
View file

@ -44,19 +44,30 @@ struct [[gnu::packed]] GUIDPartitionHeader {
u32 crc32_entries_array; u32 crc32_entries_array;
}; };
#ifdef KERNEL
ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> GUIDPartitionTable::try_to_initialize(Kernel::StorageDevice const& device) ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> GUIDPartitionTable::try_to_initialize(Kernel::StorageDevice const& device)
{ {
auto table = TRY(adopt_nonnull_own_or_enomem(new (nothrow) GUIDPartitionTable(device))); auto table = TRY(adopt_nonnull_own_or_enomem(new (nothrow) GUIDPartitionTable(device)));
#else
ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> GUIDPartitionTable::try_to_initialize(NonnullRefPtr<Core::File> device_file)
{
auto table = TRY(adopt_nonnull_own_or_enomem(new (nothrow) GUIDPartitionTable(move(device_file))));
#endif
if (!table->is_valid()) if (!table->is_valid())
return Error::from_errno(EINVAL); return Error::from_errno(EINVAL);
return table; return table;
} }
#ifdef KERNEL
GUIDPartitionTable::GUIDPartitionTable(Kernel::StorageDevice const& device) GUIDPartitionTable::GUIDPartitionTable(Kernel::StorageDevice const& device)
: MBRPartitionTable(device) : MBRPartitionTable(device)
#else
GUIDPartitionTable::GUIDPartitionTable(NonnullRefPtr<Core::File> device_file)
: MBRPartitionTable(move(device_file))
#endif
{ {
// FIXME: Handle OOM failure here. // FIXME: Handle OOM failure here.
m_cached_header = ByteBuffer::create_zeroed(m_device->block_size()).release_value_but_fixme_should_propagate_errors(); m_cached_header = ByteBuffer::create_zeroed(m_block_size).release_value_but_fixme_should_propagate_errors();
VERIFY(partitions_count() == 0); VERIFY(partitions_count() == 0);
if (!initialize()) if (!initialize())
m_valid = false; m_valid = false;
@ -71,12 +82,17 @@ bool GUIDPartitionTable::initialize()
{ {
VERIFY(m_cached_header.data() != nullptr); VERIFY(m_cached_header.data() != nullptr);
auto first_gpt_block = (m_device->block_size() == 512) ? 1 : 0; auto first_gpt_block = (m_block_size == 512) ? 1 : 0;
#ifdef KERNEL
auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_header.data()); auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_header.data());
if (!m_device->read_block(first_gpt_block, buffer)) { if (!m_device->read_block(first_gpt_block, buffer))
return false; return false;
} #else
m_device_file->seek(first_gpt_block * m_block_size);
if (m_device_file->read(m_cached_header.data(), m_cached_header.size()) != (int)m_block_size)
return false;
#endif
dbgln_if(GPT_DEBUG, "GUIDPartitionTable: signature - {:#08x} {:#08x}", header().sig[1], header().sig[0]); dbgln_if(GPT_DEBUG, "GUIDPartitionTable: signature - {:#08x} {:#08x}", header().sig[1], header().sig[0]);
@ -85,21 +101,28 @@ bool GUIDPartitionTable::initialize()
return false; return false;
} }
auto entries_buffer_result = ByteBuffer::create_zeroed(m_device->block_size()); auto entries_buffer_result = ByteBuffer::create_zeroed(m_block_size);
if (entries_buffer_result.is_error()) { if (entries_buffer_result.is_error()) {
dbgln("GUIPartitionTable: not enough memory for entries buffer"); dbgln("GUIDPartitionTable: not enough memory for entries buffer");
return false; return false;
} }
auto entries_buffer = entries_buffer_result.release_value(); auto entries_buffer = entries_buffer_result.release_value();
#ifdef KERNEL
auto raw_entries_buffer = UserOrKernelBuffer::for_kernel_buffer(entries_buffer.data()); auto raw_entries_buffer = UserOrKernelBuffer::for_kernel_buffer(entries_buffer.data());
size_t raw_byte_index = header().partition_array_start_lba * m_device->block_size(); #endif
size_t raw_byte_index = header().partition_array_start_lba * m_block_size;
for (size_t entry_index = 0; entry_index < header().entries_count; entry_index++) { for (size_t entry_index = 0; entry_index < header().entries_count; entry_index++) {
if (!m_device->read_block((raw_byte_index / m_device->block_size()), raw_entries_buffer)) { #ifdef KERNEL
if (!m_device->read_block((raw_byte_index / m_block_size), raw_entries_buffer))
return false; return false;
} #else
m_device_file->seek(raw_byte_index);
if (m_device_file->read(entries_buffer.data(), entries_buffer.size()) != (int)m_block_size)
return false;
#endif
auto* entries = (GPTPartitionEntry const*)entries_buffer.data(); auto* entries = (GPTPartitionEntry const*)entries_buffer.data();
auto& entry = entries[entry_index % (m_device->block_size() / (size_t)header().partition_entry_size)]; auto& entry = entries[entry_index % (m_block_size / (size_t)header().partition_entry_size)];
Array<u8, 16> partition_type {}; Array<u8, 16> partition_type {};
partition_type.span().overwrite(0, entry.partition_guid, partition_type.size()); partition_type.span().overwrite(0, entry.partition_guid, partition_type.size());

10
Userland/Libraries/LibPartition/GUIDPartitionTable.h
View file

@ -15,10 +15,18 @@ class GUIDPartitionTable final : public MBRPartitionTable {
public: public:
virtual ~GUIDPartitionTable() = default; virtual ~GUIDPartitionTable() = default;
#ifdef KERNEL
static ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> try_to_initialize(Kernel::StorageDevice const&); static ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> try_to_initialize(Kernel::StorageDevice const&);
explicit GUIDPartitionTable(Kernel::StorageDevice const&); explicit GUIDPartitionTable(Kernel::StorageDevice const&);
#else
static ErrorOr<NonnullOwnPtr<GUIDPartitionTable>> try_to_initialize(NonnullRefPtr<Core::File>);
explicit GUIDPartitionTable(NonnullRefPtr<Core::File>);
#endif
virtual bool is_valid() const override { return m_valid; }; virtual bool is_valid() const override
{
return m_valid;
}
private: private:
bool is_unused_entry(Array<u8, 16>) const; bool is_unused_entry(Array<u8, 16>) const;