RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 18:57:34 +00:00
Code Issues Activity Actions

Kernel+LibPartition: Move MBRPartitionTable into LibPartition

Browse source
This commit is contained in:
Samuel Bowman 2022-03-01 19:42:06 -05:00 • committed by Linus Groh
parent 940dde9947
commit 1a6ef03e4a
9 changed files with 26 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Kernel/Storage/Partition/EBRPartitionTable.h
View file

@ -12,12 +12,12 @@
#include <AK/Result.h>
#include <AK/Vector.h>
#include <Kernel/Storage/Partition/DiskPartition.h>
#include <Kernel/Storage/Partition/MBRPartitionTable.h>
#include <LibPartition/MBRPartitionTable.h>
namespace Kernel {
struct EBRPartitionHeader;
class EBRPartitionTable : public MBRPartitionTable {
class EBRPartitionTable : public Partition::MBRPartitionTable {
public:
~EBRPartitionTable();

4
Kernel/Storage/Partition/GUIDPartitionTable.h
View file

@ -11,12 +11,12 @@
#include <AK/Result.h>
#include <AK/Types.h>
#include <AK/Vector.h>
#include <Kernel/Storage/Partition/MBRPartitionTable.h>
#include <LibPartition/MBRPartitionTable.h>
namespace Kernel {
struct GUIDPartitionHeader;
class GUIDPartitionTable final : public MBRPartitionTable {
class GUIDPartitionTable final : public Partition::MBRPartitionTable {
public:
virtual ~GUIDPartitionTable() = default;
;

119
Kernel/Storage/Partition/MBRPartitionTable.cpp
View file

@ -1,119 +0,0 @@
/*
* Copyright (c) 2020-2022, Liav A. <liavalb@hotmail.co.il>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/ByteBuffer.h>
#include <Kernel/Debug.h>
#include <Kernel/Storage/Partition/MBRPartitionTable.h>
namespace Kernel {
#define MBR_SIGNATURE 0xaa55
#define MBR_PROTECTIVE 0xEE
#define EBR_CHS_CONTAINER 0x05
#define EBR_LBA_CONTAINER 0x0F
ErrorOr<NonnullOwnPtr<MBRPartitionTable>> MBRPartitionTable::try_to_initialize(StorageDevice const& device)
{
auto table = TRY(adopt_nonnull_own_or_enomem(new (nothrow) MBRPartitionTable(device)));
if (table->contains_ebr())
return Error::from_errno(ENOTSUP);
if (table->is_protective_mbr())
return Error::from_errno(ENOTSUP);
if (!table->is_valid())
return Error::from_errno(EINVAL);
return table;
}
OwnPtr<MBRPartitionTable> MBRPartitionTable::try_to_initialize(StorageDevice const& device, u32 start_lba)
{
auto table = adopt_nonnull_own_or_enomem(new (nothrow) MBRPartitionTable(device, start_lba)).release_value_but_fixme_should_propagate_errors();
if (!table->is_valid())
return {};
return table;
}
bool MBRPartitionTable::read_boot_record()
{
auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_header.data());
if (!m_device->read_block(m_start_lba, buffer))
return false;
m_header_valid = true;
return m_header_valid;
}
MBRPartitionTable::MBRPartitionTable(StorageDevice const& device, u32 start_lba)
: PartitionTable(device)
, m_start_lba(start_lba)
, m_cached_header(ByteBuffer::create_zeroed(m_device->block_size()).release_value_but_fixme_should_propagate_errors()) // FIXME: Do something sensible if this fails because of OOM.
{
if (!read_boot_record() || !initialize())
return;
m_header_valid = true;
auto& header = this->header();
for (size_t index = 0; index < 4; index++) {
auto& entry = header.entry[index];
if (entry.offset == 0x00) {
continue;
}
MUST(m_partitions.try_empend(entry.offset, (entry.offset + entry.length), entry.type));
}
m_valid = true;
}
MBRPartitionTable::MBRPartitionTable(StorageDevice const& device)
: PartitionTable(device)
, m_start_lba(0)
, m_cached_header(ByteBuffer::create_zeroed(m_device->block_size()).release_value_but_fixme_should_propagate_errors()) // FIXME: Do something sensible if this fails because of OOM.
{
if (!read_boot_record() || contains_ebr() || is_protective_mbr() || !initialize())
return;
auto& header = this->header();
for (size_t index = 0; index < 4; index++) {
auto& entry = header.entry[index];
if (entry.offset == 0x00) {
continue;
}
MUST(m_partitions.try_empend(entry.offset, (entry.offset + entry.length), entry.type));
}
m_valid = true;
}
MBRPartitionTable::~MBRPartitionTable() = default;
MBRPartitionTable::Header const& MBRPartitionTable::header() const
{
return *(MBRPartitionTable::Header const*)m_cached_header.data();
}
bool MBRPartitionTable::initialize()
{
auto& header = this->header();
dbgln_if(MBR_DEBUG, "Master Boot Record: mbr_signature={:#08x}", header.mbr_signature);
if (header.mbr_signature != MBR_SIGNATURE) {
dbgln("Master Boot Record: invalid signature");
return false;
}
return true;
}
bool MBRPartitionTable::contains_ebr() const
{
for (int i = 0; i < 4; i++) {
if (header().entry[i].type == EBR_CHS_CONTAINER || header().entry[i].type == EBR_LBA_CONTAINER)
return true;
}
return false;
}
bool MBRPartitionTable::is_protective_mbr() const
{
return header().entry[0].type == MBR_PROTECTIVE;
}
}

66
Kernel/Storage/Partition/MBRPartitionTable.h
View file

@ -1,66 +0,0 @@
/*
* Copyright (c) 2020-2022, Liav A. <liavalb@hotmail.co.il>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/Error.h>
#include <AK/RefPtr.h>
#include <AK/Result.h>
#include <AK/Vector.h>
#include <LibPartition/PartitionTable.h>
namespace Kernel {
class MBRPartitionTable : public Partition::PartitionTable {
public:
struct [[gnu::packed]] Entry {
u8 status;
u8 chs1[3];
u8 type;
u8 chs2[3];
u32 offset;
u32 length;
};
struct [[gnu::packed]] Header {
u8 code1[218];
u16 ts_zero;
u8 ts_drive;
u8 ts_seconds;
u8 ts_minutes;
u8 ts_hours;
u8 code2[216];
u32 disk_signature;
u16 disk_signature_zero;
Entry entry[4];
u16 mbr_signature;
};
public:
~MBRPartitionTable();
static ErrorOr<NonnullOwnPtr<MBRPartitionTable>> try_to_initialize(StorageDevice const&);
static OwnPtr<MBRPartitionTable> try_to_initialize(StorageDevice const&, u32 start_lba);
explicit MBRPartitionTable(StorageDevice const&);
MBRPartitionTable(StorageDevice const&, u32 start_lba);
bool is_protective_mbr() const;
bool contains_ebr() const;
virtual bool is_valid() const override { return m_valid; };
protected:
Header const& header() const;
bool is_header_valid() const { return m_header_valid; };
private:
bool read_boot_record();
bool initialize();
bool m_valid { false };
bool m_header_valid { false };
const u32 m_start_lba;
ByteBuffer m_cached_header;
};
}

4
Kernel/Storage/StorageManagement.cpp
View file

@ -23,9 +23,9 @@
#include <Kernel/Storage/NVMe/NVMeController.h>
#include <Kernel/Storage/Partition/EBRPartitionTable.h>
#include <Kernel/Storage/Partition/GUIDPartitionTable.h>
#include <Kernel/Storage/Partition/MBRPartitionTable.h>
#include <Kernel/Storage/Ramdisk/Controller.h>
#include <Kernel/Storage/StorageManagement.h>
#include <LibPartition/MBRPartitionTable.h>
namespace Kernel {
@ -133,7 +133,7 @@ UNMAP_AFTER_INIT void StorageManagement::dump_storage_devices_and_partitions() c
UNMAP_AFTER_INIT ErrorOr<NonnullOwnPtr<Partition::PartitionTable>> StorageManagement::try_to_initialize_partition_table(StorageDevice const& device) const
{
auto mbr_table_or_error = MBRPartitionTable::try_to_initialize(device);
auto mbr_table_or_error = Partition::MBRPartitionTable::try_to_initialize(device);
if (!mbr_table_or_error.is_error())
return mbr_table_or_error.release_value();
auto ebr_table_or_error = EBRPartitionTable::try_to_initialize(device);