mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 05:57:45 +00:00
Everywhere: Run clang-format
This commit is contained in:
parent
0376c127f6
commit
086969277e
1665 changed files with 8479 additions and 8479 deletions
|
@ -130,13 +130,13 @@ namespace Kernel::AHCI {
|
|||
class MaskedBitField {
|
||||
|
||||
public:
|
||||
explicit MaskedBitField(volatile u32& bitfield_register)
|
||||
explicit MaskedBitField(u32 volatile& bitfield_register)
|
||||
: m_bitfield(bitfield_register)
|
||||
, m_bit_mask(0xffffffff)
|
||||
{
|
||||
}
|
||||
|
||||
MaskedBitField(volatile u32& bitfield_register, u32 bit_mask)
|
||||
MaskedBitField(u32 volatile& bitfield_register, u32 bit_mask)
|
||||
: m_bitfield(bitfield_register)
|
||||
, m_bit_mask(bit_mask)
|
||||
{
|
||||
|
@ -180,14 +180,14 @@ public:
|
|||
u32 bit_mask() const { return m_bit_mask; };
|
||||
|
||||
// Disable default implementations that would use surprising integer promotion.
|
||||
bool operator==(const MaskedBitField&) const = delete;
|
||||
bool operator<=(const MaskedBitField&) const = delete;
|
||||
bool operator>=(const MaskedBitField&) const = delete;
|
||||
bool operator<(const MaskedBitField&) const = delete;
|
||||
bool operator>(const MaskedBitField&) const = delete;
|
||||
bool operator==(MaskedBitField const&) const = delete;
|
||||
bool operator<=(MaskedBitField const&) const = delete;
|
||||
bool operator>=(MaskedBitField const&) const = delete;
|
||||
bool operator<(MaskedBitField const&) const = delete;
|
||||
bool operator>(MaskedBitField const&) const = delete;
|
||||
|
||||
private:
|
||||
volatile u32& m_bitfield;
|
||||
u32 volatile& m_bitfield;
|
||||
const u32 m_bit_mask;
|
||||
};
|
||||
|
||||
|
@ -321,7 +321,7 @@ enum SErr : u32 {
|
|||
class PortInterruptStatusBitField {
|
||||
|
||||
public:
|
||||
explicit PortInterruptStatusBitField(volatile u32& bitfield_register)
|
||||
explicit PortInterruptStatusBitField(u32 volatile& bitfield_register)
|
||||
: m_bitfield(bitfield_register)
|
||||
{
|
||||
}
|
||||
|
@ -331,20 +331,20 @@ public:
|
|||
void clear() { m_bitfield = 0xffffffff; }
|
||||
|
||||
// Disable default implementations that would use surprising integer promotion.
|
||||
bool operator==(const MaskedBitField&) const = delete;
|
||||
bool operator<=(const MaskedBitField&) const = delete;
|
||||
bool operator>=(const MaskedBitField&) const = delete;
|
||||
bool operator<(const MaskedBitField&) const = delete;
|
||||
bool operator>(const MaskedBitField&) const = delete;
|
||||
bool operator==(MaskedBitField const&) const = delete;
|
||||
bool operator<=(MaskedBitField const&) const = delete;
|
||||
bool operator>=(MaskedBitField const&) const = delete;
|
||||
bool operator<(MaskedBitField const&) const = delete;
|
||||
bool operator>(MaskedBitField const&) const = delete;
|
||||
|
||||
private:
|
||||
volatile u32& m_bitfield;
|
||||
u32 volatile& m_bitfield;
|
||||
};
|
||||
|
||||
class PortInterruptEnableBitField {
|
||||
|
||||
public:
|
||||
explicit PortInterruptEnableBitField(volatile u32& bitfield_register)
|
||||
explicit PortInterruptEnableBitField(u32 volatile& bitfield_register)
|
||||
: m_bitfield(bitfield_register)
|
||||
{
|
||||
}
|
||||
|
@ -357,14 +357,14 @@ public:
|
|||
void set_all() { m_bitfield = 0xffffffff; }
|
||||
|
||||
// Disable default implementations that would use surprising integer promotion.
|
||||
bool operator==(const MaskedBitField&) const = delete;
|
||||
bool operator<=(const MaskedBitField&) const = delete;
|
||||
bool operator>=(const MaskedBitField&) const = delete;
|
||||
bool operator<(const MaskedBitField&) const = delete;
|
||||
bool operator>(const MaskedBitField&) const = delete;
|
||||
bool operator==(MaskedBitField const&) const = delete;
|
||||
bool operator<=(MaskedBitField const&) const = delete;
|
||||
bool operator>=(MaskedBitField const&) const = delete;
|
||||
bool operator<(MaskedBitField const&) const = delete;
|
||||
bool operator>(MaskedBitField const&) const = delete;
|
||||
|
||||
private:
|
||||
volatile u32& m_bitfield;
|
||||
u32 volatile& m_bitfield;
|
||||
};
|
||||
|
||||
struct [[gnu::packed]] PortRegisters {
|
||||
|
|
|
@ -51,7 +51,7 @@ size_t AHCIController::devices_count() const
|
|||
{
|
||||
size_t count = 0;
|
||||
for (auto& port_handler : m_handlers) {
|
||||
port_handler.enumerate_ports([&](const AHCIPort& port) {
|
||||
port_handler.enumerate_ports([&](AHCIPort const& port) {
|
||||
if (port.connected_device())
|
||||
count++;
|
||||
});
|
||||
|
@ -59,7 +59,7 @@ size_t AHCIController::devices_count() const
|
|||
return count;
|
||||
}
|
||||
|
||||
void AHCIController::start_request(const ATADevice& device, AsyncBlockDeviceRequest& request)
|
||||
void AHCIController::start_request(ATADevice const& device, AsyncBlockDeviceRequest& request)
|
||||
{
|
||||
// FIXME: For now we have one port handler, check all of them...
|
||||
VERIFY(m_handlers.size() > 0);
|
||||
|
@ -154,7 +154,7 @@ void AHCIController::initialize_hba(PCI::DeviceIdentifier const& pci_device_iden
|
|||
PCI::enable_bus_mastering(pci_address());
|
||||
enable_global_interrupts();
|
||||
m_handlers.append(AHCIPortHandler::create(*this, pci_device_identifier.interrupt_line().value(),
|
||||
AHCI::MaskedBitField((volatile u32&)(hba().control_regs.pi))));
|
||||
AHCI::MaskedBitField((u32 volatile&)(hba().control_regs.pi))));
|
||||
}
|
||||
|
||||
void AHCIController::disable_global_interrupts() const
|
||||
|
|
|
@ -32,7 +32,7 @@ public:
|
|||
virtual bool reset() override;
|
||||
virtual bool shutdown() override;
|
||||
virtual size_t devices_count() const override;
|
||||
virtual void start_request(const ATADevice&, AsyncBlockDeviceRequest&) override;
|
||||
virtual void start_request(ATADevice const&, AsyncBlockDeviceRequest&) override;
|
||||
virtual void complete_current_request(AsyncDeviceRequest::RequestResult) override;
|
||||
|
||||
const AHCI::HBADefinedCapabilities& hba_capabilities() const { return m_capabilities; };
|
||||
|
|
|
@ -20,17 +20,17 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
NonnullRefPtr<AHCIPort> AHCIPort::create(const AHCIPortHandler& handler, volatile AHCI::PortRegisters& registers, u32 port_index)
|
||||
NonnullRefPtr<AHCIPort> AHCIPort::create(AHCIPortHandler const& handler, volatile AHCI::PortRegisters& registers, u32 port_index)
|
||||
{
|
||||
return adopt_ref(*new AHCIPort(handler, registers, port_index));
|
||||
}
|
||||
|
||||
AHCIPort::AHCIPort(const AHCIPortHandler& handler, volatile AHCI::PortRegisters& registers, u32 port_index)
|
||||
AHCIPort::AHCIPort(AHCIPortHandler const& handler, volatile AHCI::PortRegisters& registers, u32 port_index)
|
||||
: m_port_index(port_index)
|
||||
, m_port_registers(registers)
|
||||
, m_parent_handler(handler)
|
||||
, m_interrupt_status((volatile u32&)m_port_registers.is)
|
||||
, m_interrupt_enable((volatile u32&)m_port_registers.ie)
|
||||
, m_interrupt_status((u32 volatile&)m_port_registers.is)
|
||||
, m_interrupt_enable((u32 volatile&)m_port_registers.ie)
|
||||
{
|
||||
if (is_interface_disabled()) {
|
||||
m_disabled_by_firmware = true;
|
||||
|
@ -319,7 +319,7 @@ bool AHCIPort::initialize()
|
|||
return true;
|
||||
}
|
||||
|
||||
const char* AHCIPort::try_disambiguate_sata_status()
|
||||
char const* AHCIPort::try_disambiguate_sata_status()
|
||||
{
|
||||
switch (m_port_registers.ssts & 0xf) {
|
||||
case 0:
|
||||
|
|
|
@ -37,7 +37,7 @@ class AHCIPort
|
|||
friend class AHCIController;
|
||||
|
||||
public:
|
||||
UNMAP_AFTER_INIT static NonnullRefPtr<AHCIPort> create(const AHCIPortHandler&, volatile AHCI::PortRegisters&, u32 port_index);
|
||||
UNMAP_AFTER_INIT static NonnullRefPtr<AHCIPort> create(AHCIPortHandler const&, volatile AHCI::PortRegisters&, u32 port_index);
|
||||
|
||||
u32 port_index() const { return m_port_index; }
|
||||
u32 representative_port_index() const { return port_index() + 1; }
|
||||
|
@ -54,13 +54,13 @@ private:
|
|||
bool is_phy_enabled() const { return (m_port_registers.ssts & 0xf) == 3; }
|
||||
bool initialize();
|
||||
|
||||
UNMAP_AFTER_INIT AHCIPort(const AHCIPortHandler&, volatile AHCI::PortRegisters&, u32 port_index);
|
||||
UNMAP_AFTER_INIT AHCIPort(AHCIPortHandler const&, volatile AHCI::PortRegisters&, u32 port_index);
|
||||
|
||||
ALWAYS_INLINE void clear_sata_error_register() const;
|
||||
|
||||
void eject();
|
||||
|
||||
const char* try_disambiguate_sata_status();
|
||||
char const* try_disambiguate_sata_status();
|
||||
void try_disambiguate_sata_error();
|
||||
|
||||
bool initiate_sata_reset();
|
||||
|
|
|
@ -46,7 +46,7 @@ AHCIPortHandler::AHCIPortHandler(AHCIController& controller, u8 irq, AHCI::Maske
|
|||
}
|
||||
}
|
||||
|
||||
void AHCIPortHandler::enumerate_ports(Function<void(const AHCIPort&)> callback) const
|
||||
void AHCIPortHandler::enumerate_ports(Function<void(AHCIPort const&)> callback) const
|
||||
{
|
||||
for (auto& port : m_handled_ports) {
|
||||
callback(*port.value);
|
||||
|
@ -70,7 +70,7 @@ PhysicalAddress AHCIPortHandler::get_identify_metadata_physical_region(u32 port_
|
|||
|
||||
AHCI::MaskedBitField AHCIPortHandler::create_pending_ports_interrupts_bitfield() const
|
||||
{
|
||||
return AHCI::MaskedBitField((volatile u32&)m_parent_controller->hba().control_regs.is, m_taken_ports.bit_mask());
|
||||
return AHCI::MaskedBitField((u32 volatile&)m_parent_controller->hba().control_regs.is, m_taken_ports.bit_mask());
|
||||
}
|
||||
|
||||
AHCI::HBADefinedCapabilities AHCIPortHandler::hba_capabilities() const
|
||||
|
@ -80,7 +80,7 @@ AHCI::HBADefinedCapabilities AHCIPortHandler::hba_capabilities() const
|
|||
|
||||
AHCIPortHandler::~AHCIPortHandler() = default;
|
||||
|
||||
bool AHCIPortHandler::handle_irq(const RegisterState&)
|
||||
bool AHCIPortHandler::handle_irq(RegisterState const&)
|
||||
{
|
||||
dbgln_if(AHCI_DEBUG, "AHCI Port Handler: IRQ received");
|
||||
if (m_pending_ports_interrupts.is_zeroed())
|
||||
|
|
|
@ -47,7 +47,7 @@ private:
|
|||
UNMAP_AFTER_INIT AHCIPortHandler(AHCIController&, u8 irq, AHCI::MaskedBitField taken_ports);
|
||||
|
||||
//^ IRQHandler
|
||||
virtual bool handle_irq(const RegisterState&) override;
|
||||
virtual bool handle_irq(RegisterState const&) override;
|
||||
|
||||
enum class Direction : u8 {
|
||||
Read,
|
||||
|
@ -59,7 +59,7 @@ private:
|
|||
void start_request(AsyncBlockDeviceRequest&, bool, bool, u16);
|
||||
void complete_current_request(AsyncDeviceRequest::RequestResult);
|
||||
|
||||
void enumerate_ports(Function<void(const AHCIPort&)> callback) const;
|
||||
void enumerate_ports(Function<void(AHCIPort const&)> callback) const;
|
||||
RefPtr<AHCIPort> port_at_index(u32 port_index) const;
|
||||
|
||||
// Data members
|
||||
|
|
|
@ -21,7 +21,7 @@ class ATAController
|
|||
: public StorageController
|
||||
, public Weakable<ATAController> {
|
||||
public:
|
||||
virtual void start_request(const ATADevice&, AsyncBlockDeviceRequest&) = 0;
|
||||
virtual void start_request(ATADevice const&, AsyncBlockDeviceRequest&) = 0;
|
||||
|
||||
protected:
|
||||
ATAController() = default;
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
ATADevice::ATADevice(const ATAController& controller, ATADevice::Address ata_address, MinorNumber minor_number, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block, NonnullOwnPtr<KString> early_storage_name)
|
||||
ATADevice::ATADevice(ATAController const& controller, ATADevice::Address ata_address, MinorNumber minor_number, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block, NonnullOwnPtr<KString> early_storage_name)
|
||||
: StorageDevice(StorageManagement::storage_type_major_number(), minor_number, logical_sector_size, max_addressable_block, move(early_storage_name))
|
||||
, m_controller(controller)
|
||||
, m_ata_address(ata_address)
|
||||
|
|
|
@ -33,10 +33,10 @@ public:
|
|||
virtual void start_request(AsyncBlockDeviceRequest&) override;
|
||||
|
||||
u16 ata_capabilites() const { return m_capabilities; }
|
||||
const Address& ata_address() const { return m_ata_address; }
|
||||
Address const& ata_address() const { return m_ata_address; }
|
||||
|
||||
protected:
|
||||
ATADevice(const ATAController&, Address, MinorNumber, u16, u16, u64, NonnullOwnPtr<KString>);
|
||||
ATADevice(ATAController const&, Address, MinorNumber, u16, u16, u64, NonnullOwnPtr<KString>);
|
||||
|
||||
WeakPtr<ATAController> m_controller;
|
||||
const Address m_ata_address;
|
||||
|
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
NonnullRefPtr<ATADiskDevice> ATADiskDevice::create(const ATAController& controller, ATADevice::Address ata_address, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block)
|
||||
NonnullRefPtr<ATADiskDevice> ATADiskDevice::create(ATAController const& controller, ATADevice::Address ata_address, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block)
|
||||
{
|
||||
auto minor_device_number = StorageManagement::generate_storage_minor_number();
|
||||
|
||||
|
@ -26,7 +26,7 @@ NonnullRefPtr<ATADiskDevice> ATADiskDevice::create(const ATAController& controll
|
|||
return disk_device_or_error.release_value();
|
||||
}
|
||||
|
||||
ATADiskDevice::ATADiskDevice(const ATAController& controller, ATADevice::Address ata_address, MinorNumber minor_number, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block, NonnullOwnPtr<KString> early_storage_name)
|
||||
ATADiskDevice::ATADiskDevice(ATAController const& controller, ATADevice::Address ata_address, MinorNumber minor_number, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block, NonnullOwnPtr<KString> early_storage_name)
|
||||
: ATADevice(controller, ata_address, minor_number, capabilities, logical_sector_size, max_addressable_block, move(early_storage_name))
|
||||
{
|
||||
}
|
||||
|
|
|
@ -19,14 +19,14 @@ class ATADiskDevice final : public ATADevice {
|
|||
friend class DeviceManagement;
|
||||
|
||||
public:
|
||||
static NonnullRefPtr<ATADiskDevice> create(const ATAController&, ATADevice::Address, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block);
|
||||
static NonnullRefPtr<ATADiskDevice> create(ATAController const&, ATADevice::Address, u16 capabilities, u16 logical_sector_size, u64 max_addressable_block);
|
||||
virtual ~ATADiskDevice() override;
|
||||
|
||||
// ^StorageDevice
|
||||
virtual CommandSet command_set() const override { return CommandSet::ATA; }
|
||||
|
||||
private:
|
||||
ATADiskDevice(const ATAController&, Address, MinorNumber, u16, u16, u64, NonnullOwnPtr<KString>);
|
||||
ATADiskDevice(ATAController const&, Address, MinorNumber, u16, u16, u64, NonnullOwnPtr<KString>);
|
||||
|
||||
// ^DiskDevice
|
||||
virtual StringView class_name() const override;
|
||||
|
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
NonnullRefPtr<ATAPIDiscDevice> ATAPIDiscDevice::create(const ATAController& controller, ATADevice::Address ata_address, u16 capabilities, u64 max_addressable_block)
|
||||
NonnullRefPtr<ATAPIDiscDevice> ATAPIDiscDevice::create(ATAController const& controller, ATADevice::Address ata_address, u16 capabilities, u64 max_addressable_block)
|
||||
{
|
||||
auto minor_device_number = StorageManagement::generate_storage_minor_number();
|
||||
|
||||
|
@ -26,7 +26,7 @@ NonnullRefPtr<ATAPIDiscDevice> ATAPIDiscDevice::create(const ATAController& cont
|
|||
return disc_device_or_error.release_value();
|
||||
}
|
||||
|
||||
ATAPIDiscDevice::ATAPIDiscDevice(const ATAController& controller, ATADevice::Address ata_address, MinorNumber minor_number, u16 capabilities, u64 max_addressable_block, NonnullOwnPtr<KString> early_storage_name)
|
||||
ATAPIDiscDevice::ATAPIDiscDevice(ATAController const& controller, ATADevice::Address ata_address, MinorNumber minor_number, u16 capabilities, u64 max_addressable_block, NonnullOwnPtr<KString> early_storage_name)
|
||||
: ATADevice(controller, ata_address, minor_number, capabilities, 0, max_addressable_block, move(early_storage_name))
|
||||
{
|
||||
}
|
||||
|
|
|
@ -19,14 +19,14 @@ class ATAPIDiscDevice final : public ATADevice {
|
|||
friend class DeviceManagement;
|
||||
|
||||
public:
|
||||
static NonnullRefPtr<ATAPIDiscDevice> create(const ATAController&, ATADevice::Address, u16 capabilities, u64 max_addressable_block);
|
||||
static NonnullRefPtr<ATAPIDiscDevice> create(ATAController const&, ATADevice::Address, u16 capabilities, u64 max_addressable_block);
|
||||
virtual ~ATAPIDiscDevice() override;
|
||||
|
||||
// ^StorageDevice
|
||||
virtual CommandSet command_set() const override { return CommandSet::SCSI; }
|
||||
|
||||
private:
|
||||
ATAPIDiscDevice(const ATAController&, Address, MinorNumber, u16, u64, NonnullOwnPtr<KString>);
|
||||
ATAPIDiscDevice(ATAController const&, Address, MinorNumber, u16, u64, NonnullOwnPtr<KString>);
|
||||
|
||||
// ^DiskDevice
|
||||
virtual StringView class_name() const override;
|
||||
|
|
|
@ -13,23 +13,23 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<BMIDEChannel> BMIDEChannel::create(const IDEController& ide_controller, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<BMIDEChannel> BMIDEChannel::create(IDEController const& ide_controller, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
{
|
||||
return adopt_ref(*new BMIDEChannel(ide_controller, io_group, type));
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<BMIDEChannel> BMIDEChannel::create(const IDEController& ide_controller, u8 irq, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<BMIDEChannel> BMIDEChannel::create(IDEController const& ide_controller, u8 irq, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
{
|
||||
return adopt_ref(*new BMIDEChannel(ide_controller, irq, io_group, type));
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT BMIDEChannel::BMIDEChannel(const IDEController& controller, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
UNMAP_AFTER_INIT BMIDEChannel::BMIDEChannel(IDEController const& controller, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
: IDEChannel(controller, io_group, type)
|
||||
{
|
||||
initialize();
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT BMIDEChannel::BMIDEChannel(const IDEController& controller, u8 irq, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
UNMAP_AFTER_INIT BMIDEChannel::BMIDEChannel(IDEController const& controller, u8 irq, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
: IDEChannel(controller, irq, io_group, type)
|
||||
{
|
||||
initialize();
|
||||
|
@ -71,7 +71,7 @@ static void print_ide_status(u8 status)
|
|||
(status & ATA_SR_ERR) != 0);
|
||||
}
|
||||
|
||||
bool BMIDEChannel::handle_irq(const RegisterState&)
|
||||
bool BMIDEChannel::handle_irq(RegisterState const&)
|
||||
{
|
||||
u8 status = m_io_group.io_base().offset(ATA_REG_STATUS).in<u8>();
|
||||
|
||||
|
|
|
@ -25,21 +25,21 @@ class BMIDEChannel final : public IDEChannel {
|
|||
friend class PATADiskDevice;
|
||||
|
||||
public:
|
||||
static NonnullRefPtr<BMIDEChannel> create(const IDEController&, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
static NonnullRefPtr<BMIDEChannel> create(const IDEController&, u8 irq, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
static NonnullRefPtr<BMIDEChannel> create(IDEController const&, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
static NonnullRefPtr<BMIDEChannel> create(IDEController const&, u8 irq, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
virtual ~BMIDEChannel() override {};
|
||||
|
||||
virtual bool is_dma_enabled() const override { return true; };
|
||||
|
||||
private:
|
||||
BMIDEChannel(const IDEController&, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
BMIDEChannel(const IDEController&, u8 irq, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
BMIDEChannel(IDEController const&, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
BMIDEChannel(IDEController const&, u8 irq, IDEChannel::IOAddressGroup, IDEChannel::ChannelType type);
|
||||
void initialize();
|
||||
|
||||
void complete_current_request(AsyncDeviceRequest::RequestResult);
|
||||
|
||||
//^ IRQHandler
|
||||
virtual bool handle_irq(const RegisterState&) override;
|
||||
virtual bool handle_irq(RegisterState const&) override;
|
||||
|
||||
//* IDEChannel
|
||||
virtual void send_ata_io_command(LBAMode lba_mode, Direction direction) const override;
|
||||
|
|
|
@ -22,12 +22,12 @@ namespace Kernel {
|
|||
#define PATA_PRIMARY_IRQ 14
|
||||
#define PATA_SECONDARY_IRQ 15
|
||||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<IDEChannel> IDEChannel::create(const IDEController& controller, IOAddressGroup io_group, ChannelType type)
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<IDEChannel> IDEChannel::create(IDEController const& controller, IOAddressGroup io_group, ChannelType type)
|
||||
{
|
||||
return adopt_ref(*new IDEChannel(controller, io_group, type));
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<IDEChannel> IDEChannel::create(const IDEController& controller, u8 irq, IOAddressGroup io_group, ChannelType type)
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<IDEChannel> IDEChannel::create(IDEController const& controller, u8 irq, IOAddressGroup io_group, ChannelType type)
|
||||
{
|
||||
return adopt_ref(*new IDEChannel(controller, irq, io_group, type));
|
||||
}
|
||||
|
@ -77,7 +77,7 @@ UNMAP_AFTER_INIT void IDEChannel::initialize()
|
|||
clear_pending_interrupts();
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT IDEChannel::IDEChannel(const IDEController& controller, u8 irq, IOAddressGroup io_group, ChannelType type)
|
||||
UNMAP_AFTER_INIT IDEChannel::IDEChannel(IDEController const& controller, u8 irq, IOAddressGroup io_group, ChannelType type)
|
||||
: IRQHandler(irq)
|
||||
, m_channel_type(type)
|
||||
, m_io_group(io_group)
|
||||
|
@ -86,7 +86,7 @@ UNMAP_AFTER_INIT IDEChannel::IDEChannel(const IDEController& controller, u8 irq,
|
|||
initialize();
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT IDEChannel::IDEChannel(const IDEController& controller, IOAddressGroup io_group, ChannelType type)
|
||||
UNMAP_AFTER_INIT IDEChannel::IDEChannel(IDEController const& controller, IOAddressGroup io_group, ChannelType type)
|
||||
: IRQHandler(type == ChannelType::Primary ? PATA_PRIMARY_IRQ : PATA_SECONDARY_IRQ)
|
||||
, m_channel_type(type)
|
||||
, m_io_group(io_group)
|
||||
|
@ -188,7 +188,7 @@ void IDEChannel::try_disambiguate_error()
|
|||
}
|
||||
}
|
||||
|
||||
bool IDEChannel::handle_irq(const RegisterState&)
|
||||
bool IDEChannel::handle_irq(RegisterState const&)
|
||||
{
|
||||
u8 status = m_io_group.io_base().offset(ATA_REG_STATUS).in<u8>();
|
||||
|
||||
|
@ -394,7 +394,7 @@ UNMAP_AFTER_INIT void IDEChannel::detect_disks()
|
|||
for (u32 i = 93; i > 54 && bbuf[i] == ' '; --i)
|
||||
bbuf[i] = 0;
|
||||
|
||||
volatile ATAIdentifyBlock& identify_block = (volatile ATAIdentifyBlock&)(*wbuf.data());
|
||||
ATAIdentifyBlock volatile& identify_block = (ATAIdentifyBlock volatile&)(*wbuf.data());
|
||||
|
||||
u16 capabilities = identify_block.capabilities[0];
|
||||
|
||||
|
|
|
@ -74,11 +74,11 @@ public:
|
|||
IOAddressGroup(IOAddressGroup const&) = default;
|
||||
|
||||
// Disable default implementations that would use surprising integer promotion.
|
||||
bool operator==(const IOAddressGroup&) const = delete;
|
||||
bool operator<=(const IOAddressGroup&) const = delete;
|
||||
bool operator>=(const IOAddressGroup&) const = delete;
|
||||
bool operator<(const IOAddressGroup&) const = delete;
|
||||
bool operator>(const IOAddressGroup&) const = delete;
|
||||
bool operator==(IOAddressGroup const&) const = delete;
|
||||
bool operator<=(IOAddressGroup const&) const = delete;
|
||||
bool operator>=(IOAddressGroup const&) const = delete;
|
||||
bool operator<(IOAddressGroup const&) const = delete;
|
||||
bool operator>(IOAddressGroup const&) const = delete;
|
||||
|
||||
IOAddress io_base() const { return m_io_base; };
|
||||
IOAddress control_base() const { return m_control_base; }
|
||||
|
@ -91,8 +91,8 @@ public:
|
|||
};
|
||||
|
||||
public:
|
||||
static NonnullRefPtr<IDEChannel> create(const IDEController&, IOAddressGroup, ChannelType type);
|
||||
static NonnullRefPtr<IDEChannel> create(const IDEController&, u8 irq, IOAddressGroup, ChannelType type);
|
||||
static NonnullRefPtr<IDEChannel> create(IDEController const&, IOAddressGroup, ChannelType type);
|
||||
static NonnullRefPtr<IDEChannel> create(IDEController const&, u8 irq, IOAddressGroup, ChannelType type);
|
||||
virtual ~IDEChannel() override;
|
||||
|
||||
RefPtr<StorageDevice> master_device() const;
|
||||
|
@ -119,10 +119,10 @@ protected:
|
|||
Write,
|
||||
};
|
||||
|
||||
IDEChannel(const IDEController&, IOAddressGroup, ChannelType type);
|
||||
IDEChannel(const IDEController&, u8 irq, IOAddressGroup, ChannelType type);
|
||||
IDEChannel(IDEController const&, IOAddressGroup, ChannelType type);
|
||||
IDEChannel(IDEController const&, u8 irq, IOAddressGroup, ChannelType type);
|
||||
//^ IRQHandler
|
||||
virtual bool handle_irq(const RegisterState&) override;
|
||||
virtual bool handle_irq(RegisterState const&) override;
|
||||
|
||||
virtual void send_ata_io_command(LBAMode lba_mode, Direction direction) const;
|
||||
|
||||
|
|
|
@ -41,7 +41,7 @@ size_t IDEController::devices_count() const
|
|||
return count;
|
||||
}
|
||||
|
||||
void IDEController::start_request(const ATADevice& device, AsyncBlockDeviceRequest& request)
|
||||
void IDEController::start_request(ATADevice const& device, AsyncBlockDeviceRequest& request)
|
||||
{
|
||||
auto& address = device.ata_address();
|
||||
VERIFY(address.subport < 2);
|
||||
|
|
|
@ -26,7 +26,7 @@ public:
|
|||
virtual bool reset() override final;
|
||||
virtual bool shutdown() override final;
|
||||
virtual size_t devices_count() const override final;
|
||||
virtual void start_request(const ATADevice&, AsyncBlockDeviceRequest&) override final;
|
||||
virtual void start_request(ATADevice const&, AsyncBlockDeviceRequest&) override final;
|
||||
virtual void complete_current_request(AsyncDeviceRequest::RequestResult) override final;
|
||||
|
||||
protected:
|
||||
|
|
|
@ -53,7 +53,7 @@ bool PCIIDEController::is_bus_master_capable() const
|
|||
return m_prog_if.value() & (1 << 7);
|
||||
}
|
||||
|
||||
static const char* detect_controller_type(u8 programming_value)
|
||||
static char const* detect_controller_type(u8 programming_value)
|
||||
{
|
||||
switch (programming_value) {
|
||||
case 0x00:
|
||||
|
|
|
@ -21,7 +21,7 @@
|
|||
namespace Kernel {
|
||||
Atomic<u8> NVMeController::controller_id {};
|
||||
|
||||
UNMAP_AFTER_INIT ErrorOr<NonnullRefPtr<NVMeController>> NVMeController::try_initialize(const Kernel::PCI::DeviceIdentifier& device_identifier, bool is_queue_polled)
|
||||
UNMAP_AFTER_INIT ErrorOr<NonnullRefPtr<NVMeController>> NVMeController::try_initialize(Kernel::PCI::DeviceIdentifier const& device_identifier, bool is_queue_polled)
|
||||
{
|
||||
auto controller = TRY(adopt_nonnull_ref_or_enomem(new NVMeController(device_identifier)));
|
||||
TRY(controller->initialize(is_queue_polled));
|
||||
|
|
|
@ -18,7 +18,7 @@ UNMAP_AFTER_INIT NVMeInterruptQueue::NVMeInterruptQueue(NonnullOwnPtr<Memory::Re
|
|||
enable_irq();
|
||||
}
|
||||
|
||||
bool NVMeInterruptQueue::handle_irq(const RegisterState&)
|
||||
bool NVMeInterruptQueue::handle_irq(RegisterState const&)
|
||||
{
|
||||
SpinlockLocker lock(m_request_lock);
|
||||
return process_cq() ? true : false;
|
||||
|
|
|
@ -28,7 +28,7 @@ DiskPartition::DiskPartition(BlockDevice& device, unsigned minor_number, DiskPar
|
|||
|
||||
DiskPartition::~DiskPartition() = default;
|
||||
|
||||
const DiskPartitionMetadata& DiskPartition::metadata() const
|
||||
DiskPartitionMetadata const& DiskPartition::metadata() const
|
||||
{
|
||||
return m_metadata;
|
||||
}
|
||||
|
@ -52,21 +52,21 @@ ErrorOr<size_t> DiskPartition::read(OpenFileDescription& fd, u64 offset, UserOrK
|
|||
return m_device.strong_ref()->read(fd, offset + adjust, outbuf, len);
|
||||
}
|
||||
|
||||
bool DiskPartition::can_read(const OpenFileDescription& fd, u64 offset) const
|
||||
bool DiskPartition::can_read(OpenFileDescription const& fd, u64 offset) const
|
||||
{
|
||||
u64 adjust = m_metadata.start_block() * block_size();
|
||||
dbgln_if(OFFD_DEBUG, "DiskPartition::can_read offset={}, adjust={}", offset, adjust);
|
||||
return m_device.strong_ref()->can_read(fd, offset + adjust);
|
||||
}
|
||||
|
||||
ErrorOr<size_t> DiskPartition::write(OpenFileDescription& fd, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
|
||||
ErrorOr<size_t> DiskPartition::write(OpenFileDescription& fd, u64 offset, UserOrKernelBuffer const& inbuf, size_t len)
|
||||
{
|
||||
u64 adjust = m_metadata.start_block() * block_size();
|
||||
dbgln_if(OFFD_DEBUG, "DiskPartition::write offset={}, adjust={}, len={}", offset, adjust, len);
|
||||
return m_device.strong_ref()->write(fd, offset + adjust, inbuf, len);
|
||||
}
|
||||
|
||||
bool DiskPartition::can_write(const OpenFileDescription& fd, u64 offset) const
|
||||
bool DiskPartition::can_write(OpenFileDescription const& fd, u64 offset) const
|
||||
{
|
||||
u64 adjust = m_metadata.start_block() * block_size();
|
||||
dbgln_if(OFFD_DEBUG, "DiskPartition::can_write offset={}, adjust={}", offset, adjust);
|
||||
|
|
|
@ -24,11 +24,11 @@ public:
|
|||
|
||||
// ^BlockDevice
|
||||
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
|
||||
virtual bool can_read(const OpenFileDescription&, u64) const override;
|
||||
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
|
||||
virtual bool can_write(const OpenFileDescription&, u64) const override;
|
||||
virtual bool can_read(OpenFileDescription const&, u64) const override;
|
||||
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
|
||||
virtual bool can_write(OpenFileDescription const&, u64) const override;
|
||||
|
||||
const DiskPartitionMetadata& metadata() const;
|
||||
DiskPartitionMetadata const& metadata() const;
|
||||
|
||||
private:
|
||||
DiskPartition(BlockDevice&, unsigned, DiskPartitionMetadata);
|
||||
|
|
|
@ -34,7 +34,7 @@ bool DiskPartitionMetadata::PartitionType::is_uuid() const
|
|||
}
|
||||
bool DiskPartitionMetadata::PartitionType::is_valid() const
|
||||
{
|
||||
return !all_of(m_partition_type, [](const auto octet) { return octet == 0; });
|
||||
return !all_of(m_partition_type, [](auto const octet) { return octet == 0; });
|
||||
}
|
||||
|
||||
DiskPartitionMetadata::DiskPartitionMetadata(u64 start_block, u64 end_block, u8 partition_type)
|
||||
|
@ -86,7 +86,7 @@ Optional<u64> DiskPartitionMetadata::special_attributes() const
|
|||
return m_attributes;
|
||||
}
|
||||
|
||||
const DiskPartitionMetadata::PartitionType& DiskPartitionMetadata::type() const
|
||||
DiskPartitionMetadata::PartitionType const& DiskPartitionMetadata::type() const
|
||||
{
|
||||
return m_type;
|
||||
}
|
||||
|
|
|
@ -40,7 +40,7 @@ public:
|
|||
DiskPartitionMetadata offset(u64 blocks_count) const;
|
||||
|
||||
Optional<u64> special_attributes() const;
|
||||
const PartitionType& type() const;
|
||||
PartitionType const& type() const;
|
||||
const UUID& unique_guid() const;
|
||||
|
||||
private:
|
||||
|
|
|
@ -9,7 +9,7 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
Result<NonnullOwnPtr<EBRPartitionTable>, PartitionTable::Error> EBRPartitionTable::try_to_initialize(const StorageDevice& device)
|
||||
Result<NonnullOwnPtr<EBRPartitionTable>, PartitionTable::Error> EBRPartitionTable::try_to_initialize(StorageDevice const& device)
|
||||
{
|
||||
auto table = adopt_nonnull_own_or_enomem(new (nothrow) EBRPartitionTable(device)).release_value_but_fixme_should_propagate_errors();
|
||||
if (table->is_protective_mbr())
|
||||
|
@ -19,7 +19,7 @@ Result<NonnullOwnPtr<EBRPartitionTable>, PartitionTable::Error> EBRPartitionTabl
|
|||
return table;
|
||||
}
|
||||
|
||||
void EBRPartitionTable::search_extended_partition(const StorageDevice& device, MBRPartitionTable& checked_ebr, u64 current_block_offset, size_t limit)
|
||||
void EBRPartitionTable::search_extended_partition(StorageDevice const& device, MBRPartitionTable& checked_ebr, u64 current_block_offset, size_t limit)
|
||||
{
|
||||
if (limit == 0)
|
||||
return;
|
||||
|
@ -39,7 +39,7 @@ void EBRPartitionTable::search_extended_partition(const StorageDevice& device, M
|
|||
search_extended_partition(device, *next_ebr, current_block_offset, (limit - 1));
|
||||
}
|
||||
|
||||
EBRPartitionTable::EBRPartitionTable(const StorageDevice& device)
|
||||
EBRPartitionTable::EBRPartitionTable(StorageDevice const& device)
|
||||
: MBRPartitionTable(device)
|
||||
{
|
||||
if (!is_header_valid())
|
||||
|
|
|
@ -20,12 +20,12 @@ class EBRPartitionTable : public MBRPartitionTable {
|
|||
public:
|
||||
~EBRPartitionTable();
|
||||
|
||||
static Result<NonnullOwnPtr<EBRPartitionTable>, PartitionTable::Error> try_to_initialize(const StorageDevice&);
|
||||
explicit EBRPartitionTable(const StorageDevice&);
|
||||
static Result<NonnullOwnPtr<EBRPartitionTable>, PartitionTable::Error> try_to_initialize(StorageDevice const&);
|
||||
explicit EBRPartitionTable(StorageDevice const&);
|
||||
virtual bool is_valid() const override { return m_valid; };
|
||||
|
||||
private:
|
||||
void search_extended_partition(const StorageDevice&, MBRPartitionTable&, u64, size_t limit);
|
||||
void search_extended_partition(StorageDevice const&, MBRPartitionTable&, u64, size_t limit);
|
||||
|
||||
bool m_valid { false };
|
||||
};
|
||||
|
|
|
@ -47,7 +47,7 @@ struct [[gnu::packed]] GUIDPartitionHeader {
|
|||
u32 crc32_entries_array;
|
||||
};
|
||||
|
||||
Result<NonnullOwnPtr<GUIDPartitionTable>, PartitionTable::Error> GUIDPartitionTable::try_to_initialize(const StorageDevice& device)
|
||||
Result<NonnullOwnPtr<GUIDPartitionTable>, PartitionTable::Error> GUIDPartitionTable::try_to_initialize(StorageDevice const& device)
|
||||
{
|
||||
auto table = adopt_nonnull_own_or_enomem(new (nothrow) GUIDPartitionTable(device)).release_value_but_fixme_should_propagate_errors();
|
||||
if (!table->is_valid())
|
||||
|
@ -55,7 +55,7 @@ Result<NonnullOwnPtr<GUIDPartitionTable>, PartitionTable::Error> GUIDPartitionTa
|
|||
return table;
|
||||
}
|
||||
|
||||
GUIDPartitionTable::GUIDPartitionTable(const StorageDevice& device)
|
||||
GUIDPartitionTable::GUIDPartitionTable(StorageDevice const& device)
|
||||
: MBRPartitionTable(device)
|
||||
{
|
||||
// FIXME: Handle OOM failure here.
|
||||
|
@ -65,9 +65,9 @@ GUIDPartitionTable::GUIDPartitionTable(const StorageDevice& device)
|
|||
m_valid = false;
|
||||
}
|
||||
|
||||
const GUIDPartitionHeader& GUIDPartitionTable::header() const
|
||||
GUIDPartitionHeader const& GUIDPartitionTable::header() const
|
||||
{
|
||||
return *(const GUIDPartitionHeader*)m_cached_header.data();
|
||||
return *(GUIDPartitionHeader const*)m_cached_header.data();
|
||||
}
|
||||
|
||||
bool GUIDPartitionTable::initialize()
|
||||
|
@ -101,7 +101,7 @@ bool GUIDPartitionTable::initialize()
|
|||
if (!m_device->read_block((raw_byte_index / m_device->block_size()), raw_entries_buffer)) {
|
||||
return false;
|
||||
}
|
||||
auto* entries = (const GPTPartitionEntry*)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)];
|
||||
Array<u8, 16> partition_type {};
|
||||
partition_type.span().overwrite(0, entry.partition_guid, partition_type.size());
|
||||
|
@ -123,7 +123,7 @@ bool GUIDPartitionTable::initialize()
|
|||
|
||||
bool GUIDPartitionTable::is_unused_entry(Array<u8, 16> partition_type) const
|
||||
{
|
||||
return all_of(partition_type, [](const auto octet) { return octet == 0; });
|
||||
return all_of(partition_type, [](auto const octet) { return octet == 0; });
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -20,14 +20,14 @@ public:
|
|||
virtual ~GUIDPartitionTable() = default;
|
||||
;
|
||||
|
||||
static Result<NonnullOwnPtr<GUIDPartitionTable>, PartitionTable::Error> try_to_initialize(const StorageDevice&);
|
||||
explicit GUIDPartitionTable(const StorageDevice&);
|
||||
static Result<NonnullOwnPtr<GUIDPartitionTable>, PartitionTable::Error> try_to_initialize(StorageDevice const&);
|
||||
explicit GUIDPartitionTable(StorageDevice const&);
|
||||
|
||||
virtual bool is_valid() const override { return m_valid; };
|
||||
|
||||
private:
|
||||
bool is_unused_entry(Array<u8, 16>) const;
|
||||
const GUIDPartitionHeader& header() const;
|
||||
GUIDPartitionHeader const& header() const;
|
||||
bool initialize();
|
||||
|
||||
bool m_valid { true };
|
||||
|
|
|
@ -15,7 +15,7 @@ namespace Kernel {
|
|||
#define EBR_CHS_CONTAINER 0x05
|
||||
#define EBR_LBA_CONTAINER 0x0F
|
||||
|
||||
Result<NonnullOwnPtr<MBRPartitionTable>, PartitionTable::Error> MBRPartitionTable::try_to_initialize(const StorageDevice& device)
|
||||
Result<NonnullOwnPtr<MBRPartitionTable>, PartitionTable::Error> MBRPartitionTable::try_to_initialize(StorageDevice const& device)
|
||||
{
|
||||
auto table = adopt_nonnull_own_or_enomem(new (nothrow) MBRPartitionTable(device)).release_value_but_fixme_should_propagate_errors();
|
||||
if (table->contains_ebr())
|
||||
|
@ -27,7 +27,7 @@ Result<NonnullOwnPtr<MBRPartitionTable>, PartitionTable::Error> MBRPartitionTabl
|
|||
return table;
|
||||
}
|
||||
|
||||
OwnPtr<MBRPartitionTable> MBRPartitionTable::try_to_initialize(const StorageDevice& device, u32 start_lba)
|
||||
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())
|
||||
|
@ -44,7 +44,7 @@ bool MBRPartitionTable::read_boot_record()
|
|||
return m_header_valid;
|
||||
}
|
||||
|
||||
MBRPartitionTable::MBRPartitionTable(const StorageDevice& device, u32 start_lba)
|
||||
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.
|
||||
|
@ -65,7 +65,7 @@ MBRPartitionTable::MBRPartitionTable(const StorageDevice& device, u32 start_lba)
|
|||
m_valid = true;
|
||||
}
|
||||
|
||||
MBRPartitionTable::MBRPartitionTable(const StorageDevice& device)
|
||||
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.
|
||||
|
@ -86,9 +86,9 @@ MBRPartitionTable::MBRPartitionTable(const StorageDevice& device)
|
|||
|
||||
MBRPartitionTable::~MBRPartitionTable() = default;
|
||||
|
||||
const MBRPartitionTable::Header& MBRPartitionTable::header() const
|
||||
MBRPartitionTable::Header const& MBRPartitionTable::header() const
|
||||
{
|
||||
return *(const MBRPartitionTable::Header*)m_cached_header.data();
|
||||
return *(MBRPartitionTable::Header const*)m_cached_header.data();
|
||||
}
|
||||
|
||||
bool MBRPartitionTable::initialize()
|
||||
|
|
|
@ -41,17 +41,17 @@ public:
|
|||
public:
|
||||
~MBRPartitionTable();
|
||||
|
||||
static Result<NonnullOwnPtr<MBRPartitionTable>, PartitionTable::Error> try_to_initialize(const StorageDevice&);
|
||||
static OwnPtr<MBRPartitionTable> try_to_initialize(const StorageDevice&, u32 start_lba);
|
||||
explicit MBRPartitionTable(const StorageDevice&);
|
||||
MBRPartitionTable(const StorageDevice&, u32 start_lba);
|
||||
static Result<NonnullOwnPtr<MBRPartitionTable>, PartitionTable::Error> 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:
|
||||
const Header& header() const;
|
||||
Header const& header() const;
|
||||
bool is_header_valid() const { return m_header_valid; };
|
||||
|
||||
private:
|
||||
|
|
|
@ -7,7 +7,7 @@
|
|||
#include <Kernel/Storage/Partition/PartitionTable.h>
|
||||
|
||||
namespace Kernel {
|
||||
PartitionTable::PartitionTable(const StorageDevice& device)
|
||||
PartitionTable::PartitionTable(StorageDevice const& device)
|
||||
: m_device(device)
|
||||
{
|
||||
}
|
||||
|
|
|
@ -31,7 +31,7 @@ public:
|
|||
Vector<DiskPartitionMetadata> partitions() const { return m_partitions; }
|
||||
|
||||
protected:
|
||||
explicit PartitionTable(const StorageDevice&);
|
||||
explicit PartitionTable(StorageDevice const&);
|
||||
|
||||
NonnullRefPtr<StorageDevice> m_device;
|
||||
Vector<DiskPartitionMetadata> m_partitions;
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
NonnullRefPtr<RamdiskDevice> RamdiskDevice::create(const RamdiskController& controller, NonnullOwnPtr<Memory::Region>&& region, int major, int minor)
|
||||
NonnullRefPtr<RamdiskDevice> RamdiskDevice::create(RamdiskController const& 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;
|
||||
|
@ -25,7 +25,7 @@ NonnullRefPtr<RamdiskDevice> RamdiskDevice::create(const RamdiskController& cont
|
|||
return device_or_error.release_value();
|
||||
}
|
||||
|
||||
RamdiskDevice::RamdiskDevice(const RamdiskController&, NonnullOwnPtr<Memory::Region>&& region, int major, int minor, NonnullOwnPtr<KString> device_name)
|
||||
RamdiskDevice::RamdiskDevice(RamdiskController const&, 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))
|
||||
{
|
||||
|
|
|
@ -18,14 +18,14 @@ class RamdiskDevice final : public StorageDevice {
|
|||
friend class DeviceManagement;
|
||||
|
||||
public:
|
||||
static NonnullRefPtr<RamdiskDevice> create(const RamdiskController&, NonnullOwnPtr<Memory::Region>&& region, int major, int minor);
|
||||
static NonnullRefPtr<RamdiskDevice> create(RamdiskController const&, NonnullOwnPtr<Memory::Region>&& region, int major, int minor);
|
||||
virtual ~RamdiskDevice() override;
|
||||
|
||||
// ^DiskDevice
|
||||
virtual StringView class_name() const override;
|
||||
|
||||
private:
|
||||
RamdiskDevice(const RamdiskController&, NonnullOwnPtr<Memory::Region>&&, int major, int minor, NonnullOwnPtr<KString> device_name);
|
||||
RamdiskDevice(RamdiskController const&, NonnullOwnPtr<Memory::Region>&&, int major, int minor, NonnullOwnPtr<KString> device_name);
|
||||
|
||||
// ^BlockDevice
|
||||
virtual void start_request(AsyncBlockDeviceRequest&) override;
|
||||
|
|
|
@ -88,12 +88,12 @@ ErrorOr<size_t> StorageDevice::read(OpenFileDescription&, u64 offset, UserOrKern
|
|||
return pos + remaining;
|
||||
}
|
||||
|
||||
bool StorageDevice::can_read(const OpenFileDescription&, u64 offset) const
|
||||
bool StorageDevice::can_read(OpenFileDescription const&, u64 offset) const
|
||||
{
|
||||
return offset < (max_addressable_block() * block_size());
|
||||
}
|
||||
|
||||
ErrorOr<size_t> StorageDevice::write(OpenFileDescription&, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
|
||||
ErrorOr<size_t> StorageDevice::write(OpenFileDescription&, u64 offset, UserOrKernelBuffer const& inbuf, size_t len)
|
||||
{
|
||||
u64 index = offset >> block_size_log();
|
||||
off_t offset_within_block = 0;
|
||||
|
@ -188,7 +188,7 @@ StringView StorageDevice::early_storage_name() const
|
|||
return m_early_storage_device_name->view();
|
||||
}
|
||||
|
||||
bool StorageDevice::can_write(const OpenFileDescription&, u64 offset) const
|
||||
bool StorageDevice::can_write(OpenFileDescription const&, u64 offset) const
|
||||
{
|
||||
return offset < (max_addressable_block() * block_size());
|
||||
}
|
||||
|
|
|
@ -38,9 +38,9 @@ public:
|
|||
|
||||
// ^BlockDevice
|
||||
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
|
||||
virtual bool can_read(const OpenFileDescription&, u64) const override;
|
||||
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
|
||||
virtual bool can_write(const OpenFileDescription&, u64) const override;
|
||||
virtual bool can_read(OpenFileDescription const&, u64) const override;
|
||||
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
|
||||
virtual bool can_write(OpenFileDescription const&, u64) const override;
|
||||
virtual void prepare_for_unplug() { m_partitions.clear(); }
|
||||
|
||||
// FIXME: Remove this method after figuring out another scheme for naming.
|
||||
|
|
|
@ -129,7 +129,7 @@ UNMAP_AFTER_INIT void StorageManagement::dump_storage_devices_and_partitions() c
|
|||
}
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT OwnPtr<PartitionTable> StorageManagement::try_to_initialize_partition_table(const StorageDevice& device) const
|
||||
UNMAP_AFTER_INIT OwnPtr<PartitionTable> StorageManagement::try_to_initialize_partition_table(StorageDevice const& device) const
|
||||
{
|
||||
auto mbr_table_or_result = MBRPartitionTable::try_to_initialize(device);
|
||||
if (!mbr_table_or_result.is_error())
|
||||
|
|
|
@ -45,7 +45,7 @@ private:
|
|||
|
||||
void dump_storage_devices_and_partitions() const;
|
||||
|
||||
OwnPtr<PartitionTable> try_to_initialize_partition_table(const StorageDevice&) const;
|
||||
OwnPtr<PartitionTable> try_to_initialize_partition_table(StorageDevice const&) const;
|
||||
|
||||
RefPtr<BlockDevice> boot_block_device() const;
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue