RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 01:27: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

6
Kernel/Time/APICTimer.cpp
View file

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

2
Kernel/Time/APICTimer.h
View file

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

18
Kernel/Time/HPET.cpp
View file

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

16
Kernel/Time/HPET.h
View file

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

2
Kernel/Time/HPETComparator.cpp
View file

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

2
Kernel/Time/HPETComparator.h
View file

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

18
Kernel/Time/HardwareTimer.h
View file

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

4
Kernel/Time/PIT.cpp
View file

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

4
Kernel/Time/PIT.h
View file

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

6
Kernel/Time/RTC.cpp
View file

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

6
Kernel/Time/RTC.h
View file

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

8
Kernel/Time/TimeManagement.cpp
View file

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

10
Kernel/Time/TimeManagement.h
View file

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