Everywhere: Run clang-format

13 files changed, 51 insertions, 51 deletions

diff --git a/Kernel/Time/APICTimer.cpp b/Kernel/Time/APICTimer.cpp
index 273cb08b28..4131627d24 100644
--- a/Kernel/Time/APICTimer.cpp
+++ b/Kernel/Time/APICTimer.cpp
@@ -24,7 +24,7 @@ UNMAP_AFTER_INIT APICTimer* APICTimer::initialize(u8 interrupt_number, HardwareT
     return &timer.leak_ref();
 }
 
-UNMAP_AFTER_INIT APICTimer::APICTimer(u8 interrupt_number, Function<void(const RegisterState&)> callback)
+UNMAP_AFTER_INIT APICTimer::APICTimer(u8 interrupt_number, Function<void(RegisterState const&)> callback)
     : HardwareTimer<GenericInterruptHandler>(interrupt_number, move(callback))
 {
     disable_remap();
@@ -50,7 +50,7 @@ UNMAP_AFTER_INIT bool APICTimer::calibrate(HardwareTimerBase& calibration_source
     volatile u64 start_reference = 0, end_reference = 0;
     volatile u32 start_apic_count = 0, end_apic_count = 0;
     bool query_reference = calibration_source.can_query_raw();
-    auto original_source_callback = calibration_source.set_callback([&](const RegisterState&) {
+    auto original_source_callback = calibration_source.set_callback([&](RegisterState const&) {
         u32 current_timer_count = apic.get_timer_current_count();
 #ifdef APIC_TIMER_MEASURE_CPU_CLOCK
         u64 current_tsc = supports_tsc ? read_tsc() : 0;
@@ -77,7 +77,7 @@ UNMAP_AFTER_INIT bool APICTimer::calibrate(HardwareTimerBase& calibration_source
     // We don't want the APIC timer to actually fire. We do however want the
     // calbibration_source timer to fire so that we can read the current
     // tick count from the APIC timer
-    auto original_callback = set_callback([&](const RegisterState&) {
+    auto original_callback = set_callback([&](RegisterState const&) {
         // TODO: How should we handle this?
         PANIC("APICTimer: Timer fired during calibration!");
     });
diff --git a/Kernel/Time/APICTimer.h b/Kernel/Time/APICTimer.h
index 400adb79be..88d51c6e90 100644
--- a/Kernel/Time/APICTimer.h
+++ b/Kernel/Time/APICTimer.h
@@ -35,7 +35,7 @@ public:
     void disable_local_timer();
 
 private:
-    explicit APICTimer(u8, Function<void(const RegisterState&)>);
+    explicit APICTimer(u8, Function<void(RegisterState const&)>);
 
     bool calibrate(HardwareTimerBase&);
 
diff --git a/Kernel/Time/HPET.cpp b/Kernel/Time/HPET.cpp
index 708dd2500f..231ce1065c 100644
--- a/Kernel/Time/HPET.cpp
+++ b/Kernel/Time/HPET.cpp
@@ -90,7 +90,7 @@ static_assert(__builtin_offsetof(HPETRegistersBlock, timers[1]) == 0x120);
 // MMIO space has to be 1280 bytes and not 1024 bytes.
 static_assert(AssertSize<HPETRegistersBlock, 0x500>());
 
-static u64 read_register_safe64(const HPETRegister& reg)
+static u64 read_register_safe64(HPETRegister const& reg)
 {
 #if ARCH(X86_64)
     return reg.full;
@@ -238,7 +238,7 @@ void HPET::update_periodic_comparator_value()
     global_enable();
 }
 
-void HPET::update_non_periodic_comparator_value(const HPETComparator& comparator)
+void HPET::update_non_periodic_comparator_value(HPETComparator const& comparator)
 {
     VERIFY_INTERRUPTS_DISABLED();
     VERIFY(!comparator.is_periodic());
@@ -306,7 +306,7 @@ u64 HPET::read_main_counter() const
     return ((u64)wraps << 32) | (u64)current_value;
 }
 
-void HPET::enable_periodic_interrupt(const HPETComparator& comparator)
+void HPET::enable_periodic_interrupt(HPETComparator const& comparator)
 {
     dbgln_if(HPET_DEBUG, "HPET: Set comparator {} to be periodic.", comparator.comparator_number());
     disable(comparator);
@@ -318,7 +318,7 @@ void HPET::enable_periodic_interrupt(const HPETComparator& comparator)
     if (comparator.is_enabled())
         enable(comparator);
 }
-void HPET::disable_periodic_interrupt(const HPETComparator& comparator)
+void HPET::disable_periodic_interrupt(HPETComparator const& comparator)
 {
     dbgln_if(HPET_DEBUG, "HPET: Disable periodic interrupt in comparator {}", comparator.comparator_number());
     disable(comparator);
@@ -331,14 +331,14 @@ void HPET::disable_periodic_interrupt(const HPETComparator& comparator)
         enable(comparator);
 }
 
-void HPET::disable(const HPETComparator& comparator)
+void HPET::disable(HPETComparator const& comparator)
 {
     dbgln_if(HPET_DEBUG, "HPET: Disable comparator {}", comparator.comparator_number());
     VERIFY(comparator.comparator_number() <= m_comparators.size());
     auto& timer = registers().timers[comparator.comparator_number()];
     timer.capabilities = timer.capabilities & ~(u32)HPETFlags::TimerConfiguration::InterruptEnable;
 }
-void HPET::enable(const HPETComparator& comparator)
+void HPET::enable(HPETComparator const& comparator)
 {
     dbgln_if(HPET_DEBUG, "HPET: Enable comparator {}", comparator.comparator_number());
     VERIFY(comparator.comparator_number() <= m_comparators.size());
@@ -346,7 +346,7 @@ void HPET::enable(const HPETComparator& comparator)
     timer.capabilities = timer.capabilities | (u32)HPETFlags::TimerConfiguration::InterruptEnable;
 }
 
-Vector<unsigned> HPET::capable_interrupt_numbers(const HPETComparator& comparator)
+Vector<unsigned> HPET::capable_interrupt_numbers(HPETComparator const& comparator)
 {
     VERIFY(comparator.comparator_number() <= m_comparators.size());
     Vector<unsigned> capable_interrupts;
@@ -408,9 +408,9 @@ PhysicalAddress HPET::find_acpi_hpet_registers_block()
     return PhysicalAddress(sdt->event_timer_block.address);
 }
 
-const HPETRegistersBlock& HPET::registers() const
+HPETRegistersBlock const& HPET::registers() const
 {
-    return *(const HPETRegistersBlock*)m_hpet_mmio_region->vaddr().offset(m_physical_acpi_hpet_registers.offset_in_page()).as_ptr();
+    return *(HPETRegistersBlock const*)m_hpet_mmio_region->vaddr().offset(m_physical_acpi_hpet_registers.offset_in_page()).as_ptr();
 }
 
 HPETRegistersBlock& HPET::registers()
diff --git a/Kernel/Time/HPET.h b/Kernel/Time/HPET.h
index 620219ec98..799c3439d9 100644
--- a/Kernel/Time/HPET.h
+++ b/Kernel/Time/HPET.h
@@ -29,27 +29,27 @@ public:
     u64 raw_counter_ticks_to_ns(u64) const;
     u64 ns_to_raw_counter_ticks(u64) const;
 
-    const NonnullRefPtrVector<HPETComparator>& comparators() const { return m_comparators; }
-    void disable(const HPETComparator&);
-    void enable(const HPETComparator&);
+    NonnullRefPtrVector<HPETComparator> const& comparators() const { return m_comparators; }
+    void disable(HPETComparator const&);
+    void enable(HPETComparator const&);
 
     void update_periodic_comparator_value();
-    void update_non_periodic_comparator_value(const HPETComparator& comparator);
+    void update_non_periodic_comparator_value(HPETComparator const& comparator);
 
     void set_comparator_irq_vector(u8 comparator_number, u8 irq_vector);
 
-    void enable_periodic_interrupt(const HPETComparator& comparator);
-    void disable_periodic_interrupt(const HPETComparator& comparator);
+    void enable_periodic_interrupt(HPETComparator const& comparator);
+    void disable_periodic_interrupt(HPETComparator const& comparator);
 
     u64 update_time(u64& seconds_since_boot, u32& ticks_this_second, bool query_only);
     u64 read_main_counter_unsafe() const;
     u64 read_main_counter() const;
 
     Vector<unsigned> capable_interrupt_numbers(u8 comparator_number);
-    Vector<unsigned> capable_interrupt_numbers(const HPETComparator&);
+    Vector<unsigned> capable_interrupt_numbers(HPETComparator const&);
 
 private:
-    const HPETRegistersBlock& registers() const;
+    HPETRegistersBlock const& registers() const;
     HPETRegistersBlock& registers();
 
     void global_disable();
diff --git a/Kernel/Time/HPETComparator.cpp b/Kernel/Time/HPETComparator.cpp
index 55718053da..ce95a93fbf 100644
--- a/Kernel/Time/HPETComparator.cpp
+++ b/Kernel/Time/HPETComparator.cpp
@@ -53,7 +53,7 @@ void HPETComparator::set_non_periodic()
     HPET::the().disable_periodic_interrupt(*this);
 }
 
-bool HPETComparator::handle_irq(const RegisterState& regs)
+bool HPETComparator::handle_irq(RegisterState const& regs)
 {
     auto result = HardwareTimer::handle_irq(regs);
     if (!is_periodic())
diff --git a/Kernel/Time/HPETComparator.h b/Kernel/Time/HPETComparator.h
index a09408ce0d..584c0499be 100644
--- a/Kernel/Time/HPETComparator.h
+++ b/Kernel/Time/HPETComparator.h
@@ -43,7 +43,7 @@ public:
 
 private:
     void set_new_countdown();
-    virtual bool handle_irq(const RegisterState&) override;
+    virtual bool handle_irq(RegisterState const&) override;
     HPETComparator(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable);
     bool m_periodic : 1;
     bool m_periodic_capable : 1;
diff --git a/Kernel/Time/HardwareTimer.h b/Kernel/Time/HardwareTimer.h
index 2f637db3f4..96643e820b 100644
--- a/Kernel/Time/HardwareTimer.h
+++ b/Kernel/Time/HardwareTimer.h
@@ -36,7 +36,7 @@ public:
 
     virtual StringView model() const = 0;
     virtual HardwareTimerType timer_type() const = 0;
-    virtual Function<void(const RegisterState&)> set_callback(Function<void(const RegisterState&)>) = 0;
+    virtual Function<void(RegisterState const&)> set_callback(Function<void(RegisterState const&)>) = 0;
 
     virtual bool is_periodic() const = 0;
     virtual bool is_periodic_capable() const = 0;
@@ -73,7 +73,7 @@ public:
         return model();
     }
 
-    virtual Function<void(const RegisterState&)> set_callback(Function<void(const RegisterState&)> callback) override
+    virtual Function<void(RegisterState const&)> set_callback(Function<void(RegisterState const&)> callback) override
     {
         disable_irq();
         auto previous_callback = move(m_callback);
@@ -85,13 +85,13 @@ public:
     virtual u32 frequency() const override { return (u32)m_frequency; }
 
 protected:
-    HardwareTimer(u8 irq_number, Function<void(const RegisterState&)> callback = nullptr)
+    HardwareTimer(u8 irq_number, Function<void(RegisterState const&)> callback = nullptr)
         : IRQHandler(irq_number)
         , m_callback(move(callback))
     {
     }
 
-    virtual bool handle_irq(const RegisterState& regs) override
+    virtual bool handle_irq(RegisterState const& regs) override
     {
         // Note: if we have an IRQ on this line, it's going to be the timer always
         if (m_callback) {
@@ -104,7 +104,7 @@ protected:
     u64 m_frequency { OPTIMAL_TICKS_PER_SECOND_RATE };
 
 private:
-    Function<void(const RegisterState&)> m_callback;
+    Function<void(RegisterState const&)> m_callback;
 };
 
 template<>
@@ -122,7 +122,7 @@ public:
         return model();
     }
 
-    virtual Function<void(const RegisterState&)> set_callback(Function<void(const RegisterState&)> callback) override
+    virtual Function<void(RegisterState const&)> set_callback(Function<void(RegisterState const&)> callback) override
     {
         auto previous_callback = move(m_callback);
         m_callback = move(callback);
@@ -139,13 +139,13 @@ public:
     virtual u32 frequency() const override { return (u32)m_frequency; }
 
 protected:
-    HardwareTimer(u8 irq_number, Function<void(const RegisterState&)> callback = nullptr)
+    HardwareTimer(u8 irq_number, Function<void(RegisterState const&)> callback = nullptr)
         : GenericInterruptHandler(irq_number)
         , m_callback(move(callback))
     {
     }
 
-    virtual bool handle_interrupt(const RegisterState& regs) override
+    virtual bool handle_interrupt(RegisterState const& regs) override
     {
         // Note: if we have an IRQ on this line, it's going to be the timer always
         if (m_callback) {
@@ -158,7 +158,7 @@ protected:
     u64 m_frequency { OPTIMAL_TICKS_PER_SECOND_RATE };
 
 private:
-    Function<void(const RegisterState&)> m_callback;
+    Function<void(RegisterState const&)> m_callback;
 };
 
 }
diff --git a/Kernel/Time/PIT.cpp b/Kernel/Time/PIT.cpp
index 642b5b4686..455a77240e 100644
--- a/Kernel/Time/PIT.cpp
+++ b/Kernel/Time/PIT.cpp
@@ -16,7 +16,7 @@
 #define IRQ_TIMER 0
 namespace Kernel {
 
-UNMAP_AFTER_INIT NonnullRefPtr<PIT> PIT::initialize(Function<void(const RegisterState&)> callback)
+UNMAP_AFTER_INIT NonnullRefPtr<PIT> PIT::initialize(Function<void(RegisterState const&)> callback)
 {
     return adopt_ref(*new PIT(move(callback)));
 }
@@ -28,7 +28,7 @@ UNMAP_AFTER_INIT NonnullRefPtr<PIT> PIT::initialize(Function<void(const Register
     IO::out8(TIMER0_CTL, MSB(timer_reload));
 }
 
-PIT::PIT(Function<void(const RegisterState&)> callback)
+PIT::PIT(Function<void(RegisterState const&)> callback)
     : HardwareTimer(IRQ_TIMER, move(callback))
     , m_periodic(true)
 {
diff --git a/Kernel/Time/PIT.h b/Kernel/Time/PIT.h
index 3840693005..081ecb9523 100644
--- a/Kernel/Time/PIT.h
+++ b/Kernel/Time/PIT.h
@@ -34,7 +34,7 @@ namespace Kernel {
 
 class PIT final : public HardwareTimer<IRQHandler> {
 public:
-    static NonnullRefPtr<PIT> initialize(Function<void(const RegisterState&)>);
+    static NonnullRefPtr<PIT> initialize(Function<void(RegisterState const&)>);
     virtual HardwareTimerType timer_type() const override { return HardwareTimerType::i8253; }
     virtual StringView model() const override { return "i8254"sv; }
     virtual size_t ticks_per_second() const override;
@@ -51,7 +51,7 @@ public:
     virtual size_t calculate_nearest_possible_frequency(size_t frequency) const override;
 
 private:
-    explicit PIT(Function<void(const RegisterState&)>);
+    explicit PIT(Function<void(RegisterState const&)>);
     bool m_periodic { true };
 };
 }
diff --git a/Kernel/Time/RTC.cpp b/Kernel/Time/RTC.cpp
index 34b928644f..86c2d38842 100644
--- a/Kernel/Time/RTC.cpp
+++ b/Kernel/Time/RTC.cpp
@@ -14,11 +14,11 @@ namespace Kernel {
 #define IRQ_TIMER 8
 #define MAX_FREQUENCY 8000
 
-NonnullRefPtr<RealTimeClock> RealTimeClock::create(Function<void(const RegisterState&)> callback)
+NonnullRefPtr<RealTimeClock> RealTimeClock::create(Function<void(RegisterState const&)> callback)
 {
     return adopt_ref(*new RealTimeClock(move(callback)));
 }
-RealTimeClock::RealTimeClock(Function<void(const RegisterState&)> callback)
+RealTimeClock::RealTimeClock(Function<void(RegisterState const&)> callback)
     : HardwareTimer(IRQ_TIMER, move(callback))
 {
     InterruptDisabler disabler;
@@ -27,7 +27,7 @@ RealTimeClock::RealTimeClock(Function<void(const RegisterState&)> callback)
     CMOS::write(0x8B, CMOS::read(0xB) | 0x40);
     reset_to_default_ticks_per_second();
 }
-bool RealTimeClock::handle_irq(const RegisterState& regs)
+bool RealTimeClock::handle_irq(RegisterState const& regs)
 {
     auto result = HardwareTimer::handle_irq(regs);
     CMOS::read(0x8C);
diff --git a/Kernel/Time/RTC.h b/Kernel/Time/RTC.h
index c745194a11..c0b3ab4c7b 100644
--- a/Kernel/Time/RTC.h
+++ b/Kernel/Time/RTC.h
@@ -13,7 +13,7 @@
 namespace Kernel {
 class RealTimeClock final : public HardwareTimer<IRQHandler> {
 public:
-    static NonnullRefPtr<RealTimeClock> create(Function<void(const RegisterState&)> callback);
+    static NonnullRefPtr<RealTimeClock> create(Function<void(RegisterState const&)> callback);
     virtual HardwareTimerType timer_type() const override { return HardwareTimerType::RTC; }
     virtual StringView model() const override { return "Real Time Clock"sv; }
     virtual size_t ticks_per_second() const override;
@@ -30,7 +30,7 @@ public:
     virtual size_t calculate_nearest_possible_frequency(size_t frequency) const override;
 
 private:
-    explicit RealTimeClock(Function<void(const RegisterState&)> callback);
-    virtual bool handle_irq(const RegisterState&) override;
+    explicit RealTimeClock(Function<void(RegisterState const&)> callback);
+    virtual bool handle_irq(RegisterState const&) override;
 };
 }
diff --git a/Kernel/Time/TimeManagement.cpp b/Kernel/Time/TimeManagement.cpp
index 2b6abbb2fa..811cd7a4ef 100644
--- a/Kernel/Time/TimeManagement.cpp
+++ b/Kernel/Time/TimeManagement.cpp
@@ -70,7 +70,7 @@ Time TimeManagement::current_time(clockid_t clock_id) const
     }
 }
 
-bool TimeManagement::is_system_timer(const HardwareTimerBase& timer) const
+bool TimeManagement::is_system_timer(HardwareTimerBase const& timer) const
 {
     return &timer == m_system_timer.ptr();
 }
@@ -282,7 +282,7 @@ UNMAP_AFTER_INIT bool TimeManagement::probe_and_set_non_legacy_hardware_timers()
         taken_non_periodic_timers_count += 1;
     }
 
-    m_system_timer->set_callback([this](const RegisterState& regs) {
+    m_system_timer->set_callback([this](RegisterState const& regs) {
         // Update the time. We don't really care too much about the
         // frequency of the interrupt because we'll query the main
         // counter to get an accurate time.
@@ -343,7 +343,7 @@ UNMAP_AFTER_INIT bool TimeManagement::probe_and_set_legacy_hardware_timers()
     return true;
 }
 
-void TimeManagement::update_time(const RegisterState&)
+void TimeManagement::update_time(RegisterState const&)
 {
     TimeManagement::the().increment_time_since_boot();
 }
@@ -406,7 +406,7 @@ void TimeManagement::increment_time_since_boot()
     update_time_page();
 }
 
-void TimeManagement::system_timer_tick(const RegisterState& regs)
+void TimeManagement::system_timer_tick(RegisterState const& regs)
 {
     if (Processor::current_in_irq() <= 1) {
         // Don't expire timers while handling IRQs
diff --git a/Kernel/Time/TimeManagement.h b/Kernel/Time/TimeManagement.h
index 6c72279457..76b38ecf92 100644
--- a/Kernel/Time/TimeManagement.h
+++ b/Kernel/Time/TimeManagement.h
@@ -49,10 +49,10 @@ public:
     time_t ticks_per_second() const;
     time_t boot_time() const;
 
-    bool is_system_timer(const HardwareTimerBase&) const;
+    bool is_system_timer(HardwareTimerBase const&) const;
 
-    static void update_time(const RegisterState&);
-    static void update_time_hpet(const RegisterState&);
+    static void update_time(RegisterState const&);
+    static void update_time_hpet(RegisterState const&);
     void increment_time_since_boot_hpet();
     void increment_time_since_boot();
 
@@ -69,7 +69,7 @@ public:
     timespec remaining_epoch_time_adjustment() const { return m_remaining_epoch_time_adjustment; }
     // FIXME: Should use AK::Time internally
     // FIXME: Also, most likely broken, because it does not check m_update[12] for in-progress updates.
-    void set_remaining_epoch_time_adjustment(const timespec& adjustment) { m_remaining_epoch_time_adjustment = adjustment; }
+    void set_remaining_epoch_time_adjustment(timespec const& adjustment) { m_remaining_epoch_time_adjustment = adjustment; }
 
     bool can_query_precise_time() const { return m_can_query_precise_time; }
 
@@ -85,7 +85,7 @@ private:
     Vector<HardwareTimerBase*> scan_for_non_periodic_timers();
     NonnullRefPtrVector<HardwareTimerBase> m_hardware_timers;
     void set_system_timer(HardwareTimerBase&);
-    static void system_timer_tick(const RegisterState&);
+    static void system_timer_tick(RegisterState const&);
 
     static u64 scheduling_current_time(bool);