RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 04:47:34 +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

24
Kernel/Interrupts/APIC.cpp
View file

@ -75,7 +75,7 @@ public:
handler->register_interrupt_handler();
}
virtual bool handle_interrupt(const RegisterState&) override;
virtual bool handle_interrupt(RegisterState const&) override;
virtual bool eoi() override;
@ -106,7 +106,7 @@ public:
handler->register_interrupt_handler();
}
virtual bool handle_interrupt(const RegisterState&) override;
virtual bool handle_interrupt(RegisterState const&) override;
virtual bool eoi() override;
@ -145,7 +145,7 @@ PhysicalAddress APIC::get_base()
return PhysicalAddress(base & 0xfffff000);
}
void APIC::set_base(const PhysicalAddress& base)
void APIC::set_base(PhysicalAddress const& base)
{
MSR msr(APIC_BASE_MSR);
u64 flags = 1 << 11;
@ -160,7 +160,7 @@ void APIC::write_register(u32 offset, u32 value)
MSR msr(APIC_REGS_MSR_BASE + (offset >> 4));
msr.set(value);
} else {
*reinterpret_cast<volatile u32*>(m_apic_base->vaddr().offset(offset).as_ptr()) = value;
*reinterpret_cast<u32 volatile*>(m_apic_base->vaddr().offset(offset).as_ptr()) = value;
}
}
@ -170,7 +170,7 @@ u32 APIC::read_register(u32 offset)
MSR msr(APIC_REGS_MSR_BASE + (offset >> 4));
return (u32)msr.get();
}
return *reinterpret_cast<volatile u32*>(m_apic_base->vaddr().offset(offset).as_ptr());
return *reinterpret_cast<u32 volatile*>(m_apic_base->vaddr().offset(offset).as_ptr());
}
void APIC::set_lvt(u32 offset, u8 interrupt)
@ -190,7 +190,7 @@ void APIC::wait_for_pending_icr()
}
}
void APIC::write_icr(const ICRReg& icr)
void APIC::write_icr(ICRReg const& icr)
{
if (m_is_x2) {
MSR msr(APIC_REGS_MSR_BASE + (APIC_REG_ICR_LOW >> 4));
@ -236,7 +236,7 @@ u8 APIC::spurious_interrupt_vector()
}
#define APIC_INIT_VAR_PTR(tpe, vaddr, varname) \
reinterpret_cast<volatile tpe*>(reinterpret_cast<ptrdiff_t>(vaddr) \
reinterpret_cast<tpe volatile*>(reinterpret_cast<ptrdiff_t>(vaddr) \
+ reinterpret_cast<ptrdiff_t>(&varname) \
- reinterpret_cast<ptrdiff_t>(&apic_ap_start))
@ -349,7 +349,7 @@ UNMAP_AFTER_INIT void APIC::setup_ap_boot_environment()
VERIFY(apic_startup_region_size < USER_RANGE_BASE);
auto apic_startup_region = create_identity_mapped_region(PhysicalAddress(apic_startup_region_base), apic_startup_region_size);
u8* apic_startup_region_ptr = apic_startup_region->vaddr().as_ptr();
memcpy(apic_startup_region_ptr, reinterpret_cast<const void*>(apic_ap_start), apic_ap_start_size);
memcpy(apic_startup_region_ptr, reinterpret_cast<void const*>(apic_ap_start), apic_ap_start_size);
// Allocate enough stacks for all APs
m_ap_temporary_boot_stacks.ensure_capacity(aps_to_enable);
@ -387,9 +387,9 @@ UNMAP_AFTER_INIT void APIC::setup_ap_boot_environment()
*APIC_INIT_VAR_PTR(FlatPtr, apic_startup_region_ptr, ap_cpu_init_cr3) = MM.kernel_page_directory().cr3();
// Store the BSP's GDT and IDT for the APs to use
const auto& gdtr = Processor::current().get_gdtr();
auto const& gdtr = Processor::current().get_gdtr();
*APIC_INIT_VAR_PTR(FlatPtr, apic_startup_region_ptr, ap_cpu_gdtr) = FlatPtr(&gdtr);
const auto& idtr = get_idtr();
auto const& idtr = get_idtr();
*APIC_INIT_VAR_PTR(FlatPtr, apic_startup_region_ptr, ap_cpu_idtr) = FlatPtr(&idtr);
#if ARCH(X86_64)
@ -656,7 +656,7 @@ u32 APIC::get_timer_divisor()
return 16;
}
bool APICIPIInterruptHandler::handle_interrupt(const RegisterState&)
bool APICIPIInterruptHandler::handle_interrupt(RegisterState const&)
{
dbgln_if(APIC_SMP_DEBUG, "APIC IPI on CPU #{}", Processor::current_id());
return true;
@ -669,7 +669,7 @@ bool APICIPIInterruptHandler::eoi()
return true;
}
bool APICErrInterruptHandler::handle_interrupt(const RegisterState&)
bool APICErrInterruptHandler::handle_interrupt(RegisterState const&)
{
dbgln("APIC: SMP error on CPU #{}", Processor::current_id());
return true;

4
Kernel/Interrupts/APIC.h
View file

@ -102,13 +102,13 @@ private:
bool m_is_x2 { false };
static PhysicalAddress get_base();
void set_base(const PhysicalAddress& base);
void set_base(PhysicalAddress const& base);
void write_register(u32 offset, u32 value);
u32 read_register(u32 offset);
void set_lvt(u32 offset, u8 interrupt);
void set_siv(u32 offset, u8 interrupt);
void wait_for_pending_icr();
void write_icr(const ICRReg& icr);
void write_icr(ICRReg const& icr);
void do_boot_aps();
};

2
Kernel/Interrupts/GenericInterruptHandler.h
View file

@ -28,7 +28,7 @@ public:
}
// Note: this method returns boolean value, to indicate if the handler handled
// the interrupt or not. This is useful for shared handlers mostly.
virtual bool handle_interrupt(const RegisterState& regs) = 0;
virtual bool handle_interrupt(RegisterState const& regs) = 0;
void will_be_destroyed();
bool is_registered() const { return m_registered; }

8
Kernel/Interrupts/IOAPIC.cpp
View file

@ -102,7 +102,7 @@ bool IOAPIC::is_enabled() const
return !is_hard_disabled();
}
void IOAPIC::spurious_eoi(const GenericInterruptHandler& handler) const
void IOAPIC::spurious_eoi(GenericInterruptHandler const& handler) const
{
InterruptDisabler disabler;
VERIFY(handler.type() == HandlerType::SpuriousInterruptHandler);
@ -241,7 +241,7 @@ Optional<int> IOAPIC::find_redirection_entry_by_vector(u8 vector) const
return {};
}
void IOAPIC::disable(const GenericInterruptHandler& handler)
void IOAPIC::disable(GenericInterruptHandler const& handler)
{
InterruptDisabler disabler;
VERIFY(!is_hard_disabled());
@ -256,7 +256,7 @@ void IOAPIC::disable(const GenericInterruptHandler& handler)
mask_redirection_entry(found_index.value());
}
void IOAPIC::enable(const GenericInterruptHandler& handler)
void IOAPIC::enable(GenericInterruptHandler const& handler)
{
InterruptDisabler disabler;
VERIFY(!is_hard_disabled());
@ -271,7 +271,7 @@ void IOAPIC::enable(const GenericInterruptHandler& handler)
unmask_redirection_entry(found_index.value());
}
void IOAPIC::eoi(const GenericInterruptHandler& handler) const
void IOAPIC::eoi(GenericInterruptHandler const& handler) const
{
InterruptDisabler disabler;
VERIFY(!is_hard_disabled());

8
Kernel/Interrupts/IOAPIC.h
View file

@ -40,11 +40,11 @@ private:
class IOAPIC final : public IRQController {
public:
IOAPIC(PhysicalAddress, u32 gsi_base);
virtual void enable(const GenericInterruptHandler&) override;
virtual void disable(const GenericInterruptHandler&) override;
virtual void enable(GenericInterruptHandler const&) override;
virtual void disable(GenericInterruptHandler const&) override;
virtual void hard_disable() override;
virtual void eoi(const GenericInterruptHandler&) const override;
virtual void spurious_eoi(const GenericInterruptHandler&) const override;
virtual void eoi(GenericInterruptHandler const&) const override;
virtual void spurious_eoi(GenericInterruptHandler const&) const override;
virtual bool is_vector_enabled(u8 number) const override;
virtual bool is_enabled() const override;
virtual u16 get_isr() const override;

8
Kernel/Interrupts/IRQController.h
View file

@ -20,14 +20,14 @@ class IRQController : public RefCounted<IRQController> {
public:
virtual ~IRQController() = default;
virtual void enable(const GenericInterruptHandler&) = 0;
virtual void disable(const GenericInterruptHandler&) = 0;
virtual void enable(GenericInterruptHandler const&) = 0;
virtual void disable(GenericInterruptHandler const&) = 0;
virtual void hard_disable() { m_hard_disabled = true; }
virtual bool is_vector_enabled(u8 number) const = 0;
virtual bool is_enabled() const = 0;
bool is_hard_disabled() const { return m_hard_disabled; }
virtual void eoi(const GenericInterruptHandler&) const = 0;
virtual void spurious_eoi(const GenericInterruptHandler&) const = 0;
virtual void eoi(GenericInterruptHandler const&) const = 0;
virtual void spurious_eoi(GenericInterruptHandler const&) const = 0;
virtual size_t interrupt_vectors_count() const = 0;
virtual u32 gsi_base() const = 0;
virtual u16 get_isr() const = 0;

4
Kernel/Interrupts/IRQHandler.h
View file

@ -17,8 +17,8 @@ class IRQHandler : public GenericInterruptHandler {
public:
virtual ~IRQHandler();
virtual bool handle_interrupt(const RegisterState& regs) override { return handle_irq(regs); }
virtual bool handle_irq(const RegisterState&) = 0;
virtual bool handle_interrupt(RegisterState const& regs) override { return handle_irq(regs); }
virtual bool handle_irq(RegisterState const&) = 0;
void enable_irq();
void disable_irq();

2
Kernel/Interrupts/InterruptManagement.h
View file

@ -56,7 +56,7 @@ public:
RefPtr<IRQController> get_responsible_irq_controller(u8 interrupt_vector);
RefPtr<IRQController> get_responsible_irq_controller(IRQControllerType controller_type, u8 interrupt_vector);
const Vector<ISAInterruptOverrideMetadata>& isa_overrides() const { return m_isa_interrupt_overrides; }
Vector<ISAInterruptOverrideMetadata> const& isa_overrides() const { return m_isa_interrupt_overrides; }
u8 get_mapped_interrupt_vector(u8 original_irq);
u8 get_irq_vector(u8 mapped_interrupt_vector);

8
Kernel/Interrupts/PIC.cpp
View file

@ -45,7 +45,7 @@ bool PIC::is_enabled() const
return !is_all_masked(m_cached_irq_mask) && !is_hard_disabled();
}
void PIC::disable(const GenericInterruptHandler& handler)
void PIC::disable(GenericInterruptHandler const& handler)
{
InterruptDisabler disabler;
VERIFY(!is_hard_disabled());
@ -71,7 +71,7 @@ UNMAP_AFTER_INIT PIC::PIC()
initialize();
}
void PIC::spurious_eoi(const GenericInterruptHandler& handler) const
void PIC::spurious_eoi(GenericInterruptHandler const& handler) const
{
VERIFY(handler.type() == HandlerType::SpuriousInterruptHandler);
if (handler.interrupt_number() == 7)
@ -87,7 +87,7 @@ bool PIC::is_vector_enabled(u8 irq) const
return m_cached_irq_mask & (1 << irq);
}
void PIC::enable(const GenericInterruptHandler& handler)
void PIC::enable(GenericInterruptHandler const& handler)
{
InterruptDisabler disabler;
VERIFY(!is_hard_disabled());
@ -114,7 +114,7 @@ void PIC::enable_vector(u8 irq)
m_cached_irq_mask &= ~(1 << irq);
}
void PIC::eoi(const GenericInterruptHandler& handler) const
void PIC::eoi(GenericInterruptHandler const& handler) const
{
InterruptDisabler disabler;
VERIFY(!is_hard_disabled());

8
Kernel/Interrupts/PIC.h
View file

@ -17,13 +17,13 @@ static constexpr size_t pic_disabled_vector_end = 0x2f;
class PIC final : public IRQController {
public:
PIC();
virtual void enable(const GenericInterruptHandler&) override;
virtual void disable(const GenericInterruptHandler&) override;
virtual void enable(GenericInterruptHandler const&) override;
virtual void disable(GenericInterruptHandler const&) override;
virtual void hard_disable() override;
virtual void eoi(const GenericInterruptHandler&) const override;
virtual void eoi(GenericInterruptHandler const&) const override;
virtual bool is_vector_enabled(u8 number) const override;
virtual bool is_enabled() const override;
virtual void spurious_eoi(const GenericInterruptHandler&) const override;
virtual void spurious_eoi(GenericInterruptHandler const&) const override;
virtual u16 get_isr() const override;
virtual u16 get_irr() const override;
virtual u32 gsi_base() const override { return 0; }

2
Kernel/Interrupts/SharedIRQHandler.cpp
View file

@ -62,7 +62,7 @@ SharedIRQHandler::~SharedIRQHandler()
disable_interrupt_vector();
}
bool SharedIRQHandler::handle_interrupt(const RegisterState& regs)
bool SharedIRQHandler::handle_interrupt(RegisterState const& regs)
{
VERIFY_INTERRUPTS_DISABLED();

2
Kernel/Interrupts/SharedIRQHandler.h
View file

@ -18,7 +18,7 @@ class SharedIRQHandler final : public GenericInterruptHandler {
public:
static void initialize(u8 interrupt_number);
virtual ~SharedIRQHandler();
virtual bool handle_interrupt(const RegisterState& regs) override;
virtual bool handle_interrupt(RegisterState const& regs) override;
void register_handler(GenericInterruptHandler&);
void unregister_handler(GenericInterruptHandler&);

2
Kernel/Interrupts/SpuriousInterruptHandler.cpp
View file

@ -69,7 +69,7 @@ SpuriousInterruptHandler::SpuriousInterruptHandler(u8 irq)
SpuriousInterruptHandler::~SpuriousInterruptHandler() = default;
bool SpuriousInterruptHandler::handle_interrupt(const RegisterState& state)
bool SpuriousInterruptHandler::handle_interrupt(RegisterState const& state)
{
// Actually check if IRQ7 or IRQ15 are spurious, and if not, call the real handler to handle the IRQ.
if (m_responsible_irq_controller->get_isr() & (1 << interrupt_number())) {

2
Kernel/Interrupts/SpuriousInterruptHandler.h
View file

@ -19,7 +19,7 @@ public:
static void initialize_for_disabled_master_pic();
static void initialize_for_disabled_slave_pic();
virtual ~SpuriousInterruptHandler();
virtual bool handle_interrupt(const RegisterState& regs) override;
virtual bool handle_interrupt(RegisterState const& regs) override;
void register_handler(GenericInterruptHandler&);
void unregister_handler(GenericInterruptHandler&);

2
Kernel/Interrupts/UnhandledInterruptHandler.cpp
View file

@ -13,7 +13,7 @@ UnhandledInterruptHandler::UnhandledInterruptHandler(u8 interrupt_vector)
{
}
bool UnhandledInterruptHandler::handle_interrupt(const RegisterState&)
bool UnhandledInterruptHandler::handle_interrupt(RegisterState const&)
{
PANIC("Interrupt: Unhandled vector {} was invoked for handle_interrupt(RegisterState&).", interrupt_number());
}

2
Kernel/Interrupts/UnhandledInterruptHandler.h
View file

@ -15,7 +15,7 @@ public:
explicit UnhandledInterruptHandler(u8 interrupt_vector);
virtual ~UnhandledInterruptHandler();
virtual bool handle_interrupt(const RegisterState&) override;
virtual bool handle_interrupt(RegisterState const&) override;
[[noreturn]] virtual bool eoi() override;