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

Everywhere: Run clang-format

Browse source
This commit is contained in:
Idan Horowitz 2022-04-01 20:58:27 +03:00 • committed by Linus Groh
parent 0376c127f6
commit 086969277e
1665 changed files with 8479 additions and 8479 deletions
Download patch file Download diff file Expand all files Collapse all files

44
Kernel/Storage/ATA/AHCI.h
View file

@ -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 {

6
Kernel/Storage/ATA/AHCIController.cpp
View file

@ -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

2
Kernel/Storage/ATA/AHCIController.h
View file

@ -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; };

10
Kernel/Storage/ATA/AHCIPort.cpp
View file

@ -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:

6
Kernel/Storage/ATA/AHCIPort.h
View file

@ -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();

6
Kernel/Storage/ATA/AHCIPortHandler.cpp
View file

@ -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())

4
Kernel/Storage/ATA/AHCIPortHandler.h
View file

@ -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

2
Kernel/Storage/ATA/ATAController.h
View file

@ -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;

2
Kernel/Storage/ATA/ATADevice.cpp
View file

@ -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)

4
Kernel/Storage/ATA/ATADevice.h
View file

@ -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;

4
Kernel/Storage/ATA/ATADiskDevice.cpp
View file

@ -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))
{
}

4
Kernel/Storage/ATA/ATADiskDevice.h
View file

@ -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;

4
Kernel/Storage/ATA/ATAPIDiscDevice.cpp
View file

@ -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))
{
}

4
Kernel/Storage/ATA/ATAPIDiscDevice.h
View file

@ -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;

10
Kernel/Storage/ATA/BMIDEChannel.cpp
View file

@ -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>();

10
Kernel/Storage/ATA/BMIDEChannel.h
View file

@ -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;

12
Kernel/Storage/ATA/IDEChannel.cpp
View file

@ -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];

20
Kernel/Storage/ATA/IDEChannel.h
View file

@ -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;

2
Kernel/Storage/ATA/IDEController.cpp
View file

@ -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);

2
Kernel/Storage/ATA/IDEController.h
View file

@ -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:

2
Kernel/Storage/ATA/PCIIDEController.cpp
View file

@ -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:

2
Kernel/Storage/NVMe/NVMeController.cpp
View file

@ -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));

2
Kernel/Storage/NVMe/NVMeInterruptQueue.cpp
View file

@ -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;

8
Kernel/Storage/Partition/DiskPartition.cpp
View file

@ -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);

8
Kernel/Storage/Partition/DiskPartition.h
View file

@ -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);

4
Kernel/Storage/Partition/DiskPartitionMetadata.cpp
View file

@ -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;
}

2
Kernel/Storage/Partition/DiskPartitionMetadata.h
View file

@ -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:

6
Kernel/Storage/Partition/EBRPartitionTable.cpp
View file

@ -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())

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

@ -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 };
};

12
Kernel/Storage/Partition/GUIDPartitionTable.cpp
View file

@ -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; });
}
}

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

@ -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 };

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

@ -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()

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

@ -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:

2
Kernel/Storage/Partition/PartitionTable.cpp
View file

@ -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)
{
}

2
Kernel/Storage/Partition/PartitionTable.h
View file

@ -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;

4
Kernel/Storage/Ramdisk/Device.cpp
View file

@ -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))
{

4
Kernel/Storage/Ramdisk/Device.h
View file

@ -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;

6
Kernel/Storage/StorageDevice.cpp
View file

@ -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());
}

6
Kernel/Storage/StorageDevice.h
View file

@ -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.

2
Kernel/Storage/StorageManagement.cpp
View file

@ -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())

2
Kernel/Storage/StorageManagement.h
View file

@ -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;