mirror of
https://github.com/RGBCube/serenity
synced 2025-07-26 12:07:45 +00:00
Everywhere: Rename ASSERT => VERIFY
(...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
This commit is contained in:
Andreas Kling
parent
b33a6a443e
commit
5d180d1f99
725 changed files with 3448 additions and 3448 deletions
|
|
@ -54,7 +54,7 @@ UNMAP_AFTER_INIT APICTimer::APICTimer(u8 interrupt_number, Function<void(const R
|
|||
|
||||
UNMAP_AFTER_INIT bool APICTimer::calibrate(HardwareTimerBase& calibration_source)
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
VERIFY_INTERRUPTS_DISABLED();
|
||||
|
||||
klog() << "APICTimer: Using " << calibration_source.model() << " as calibration source";
|
||||
|
||||
|
|
@ -96,7 +96,7 @@ UNMAP_AFTER_INIT bool APICTimer::calibrate(HardwareTimerBase& calibration_source
|
|||
// tick count from the APIC timer
|
||||
auto original_callback = set_callback([&](const RegisterState&) {
|
||||
klog() << "APICTimer: Timer fired during calibration!";
|
||||
ASSERT_NOT_REACHED(); // TODO: How should we handle this?
|
||||
VERIFY_NOT_REACHED(); // TODO: How should we handle this?
|
||||
});
|
||||
apic.setup_local_timer(0xffffffff, APIC::TimerMode::Periodic, true);
|
||||
|
||||
|
|
@ -153,12 +153,12 @@ size_t APICTimer::ticks_per_second() const
|
|||
void APICTimer::set_periodic()
|
||||
{
|
||||
// FIXME: Implement it...
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
void APICTimer::set_non_periodic()
|
||||
{
|
||||
// FIXME: Implement it...
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
void APICTimer::reset_to_default_ticks_per_second()
|
||||
|
|
|
|||
|
|
@ -125,14 +125,14 @@ bool HPET::initialized()
|
|||
|
||||
HPET& HPET::the()
|
||||
{
|
||||
ASSERT(HPET::initialized());
|
||||
ASSERT(s_hpet != nullptr);
|
||||
VERIFY(HPET::initialized());
|
||||
VERIFY(s_hpet != nullptr);
|
||||
return *s_hpet;
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT bool HPET::test_and_initialize()
|
||||
{
|
||||
ASSERT(!HPET::initialized());
|
||||
VERIFY(!HPET::initialized());
|
||||
hpet_initialized = true;
|
||||
auto hpet = ACPI::Parser::the()->find_table("HPET");
|
||||
if (hpet.is_null())
|
||||
|
|
@ -142,7 +142,7 @@ UNMAP_AFTER_INIT bool HPET::test_and_initialize()
|
|||
auto sdt = map_typed<ACPI::Structures::HPET>(hpet);
|
||||
|
||||
// Note: HPET is only usable from System Memory
|
||||
ASSERT(sdt->event_timer_block.address_space == (u8)ACPI::GenericAddressStructure::AddressSpace::SystemMemory);
|
||||
VERIFY(sdt->event_timer_block.address_space == (u8)ACPI::GenericAddressStructure::AddressSpace::SystemMemory);
|
||||
|
||||
if (TimeManagement::is_hpet_periodic_mode_allowed()) {
|
||||
if (!check_for_exisiting_periodic_timers()) {
|
||||
|
|
@ -161,7 +161,7 @@ UNMAP_AFTER_INIT bool HPET::check_for_exisiting_periodic_timers()
|
|||
return false;
|
||||
|
||||
auto sdt = map_typed<ACPI::Structures::HPET>(hpet);
|
||||
ASSERT(sdt->event_timer_block.address_space == 0);
|
||||
VERIFY(sdt->event_timer_block.address_space == 0);
|
||||
auto registers = map_typed<HPETRegistersBlock>(PhysicalAddress(sdt->event_timer_block.address));
|
||||
|
||||
size_t timers_count = ((registers->capabilities.attributes >> 8) & 0x1f) + 1;
|
||||
|
|
@ -232,9 +232,9 @@ void HPET::update_periodic_comparator_value()
|
|||
|
||||
void HPET::update_non_periodic_comparator_value(const HPETComparator& comparator)
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(!comparator.is_periodic());
|
||||
ASSERT(comparator.comparator_number() <= m_comparators.size());
|
||||
VERIFY_INTERRUPTS_DISABLED();
|
||||
VERIFY(!comparator.is_periodic());
|
||||
VERIFY(comparator.comparator_number() <= m_comparators.size());
|
||||
auto& regs = registers();
|
||||
auto& timer = regs.timers[comparator.comparator_number()];
|
||||
u64 value = frequency() / comparator.ticks_per_second();
|
||||
|
|
@ -283,10 +283,10 @@ void HPET::enable_periodic_interrupt(const HPETComparator& comparator)
|
|||
klog() << "HPET: Set comparator " << comparator.comparator_number() << " to be periodic.";
|
||||
#endif
|
||||
disable(comparator);
|
||||
ASSERT(comparator.comparator_number() <= m_comparators.size());
|
||||
VERIFY(comparator.comparator_number() <= m_comparators.size());
|
||||
auto& timer = registers().timers[comparator.comparator_number()];
|
||||
auto capabilities = timer.capabilities;
|
||||
ASSERT(capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable);
|
||||
VERIFY(capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable);
|
||||
timer.capabilities = capabilities | (u32)HPETFlags::TimerConfiguration::GeneratePeriodicInterrupt;
|
||||
if (comparator.is_enabled())
|
||||
enable(comparator);
|
||||
|
|
@ -297,10 +297,10 @@ void HPET::disable_periodic_interrupt(const HPETComparator& comparator)
|
|||
klog() << "HPET: Disable periodic interrupt in comparator " << comparator.comparator_number() << ".";
|
||||
#endif
|
||||
disable(comparator);
|
||||
ASSERT(comparator.comparator_number() <= m_comparators.size());
|
||||
VERIFY(comparator.comparator_number() <= m_comparators.size());
|
||||
auto& timer = registers().timers[comparator.comparator_number()];
|
||||
auto capabilities = timer.capabilities;
|
||||
ASSERT(capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable);
|
||||
VERIFY(capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable);
|
||||
timer.capabilities = capabilities & ~(u32)HPETFlags::TimerConfiguration::GeneratePeriodicInterrupt;
|
||||
if (comparator.is_enabled())
|
||||
enable(comparator);
|
||||
|
|
@ -311,7 +311,7 @@ void HPET::disable(const HPETComparator& comparator)
|
|||
#if HPET_DEBUG
|
||||
klog() << "HPET: Disable comparator " << comparator.comparator_number() << ".";
|
||||
#endif
|
||||
ASSERT(comparator.comparator_number() <= m_comparators.size());
|
||||
VERIFY(comparator.comparator_number() <= m_comparators.size());
|
||||
auto& timer = registers().timers[comparator.comparator_number()];
|
||||
timer.capabilities = timer.capabilities & ~(u32)HPETFlags::TimerConfiguration::InterruptEnable;
|
||||
}
|
||||
|
|
@ -320,14 +320,14 @@ void HPET::enable(const HPETComparator& comparator)
|
|||
#if HPET_DEBUG
|
||||
klog() << "HPET: Enable comparator " << comparator.comparator_number() << ".";
|
||||
#endif
|
||||
ASSERT(comparator.comparator_number() <= m_comparators.size());
|
||||
VERIFY(comparator.comparator_number() <= m_comparators.size());
|
||||
auto& timer = registers().timers[comparator.comparator_number()];
|
||||
timer.capabilities = timer.capabilities | (u32)HPETFlags::TimerConfiguration::InterruptEnable;
|
||||
}
|
||||
|
||||
Vector<unsigned> HPET::capable_interrupt_numbers(const HPETComparator& comparator)
|
||||
{
|
||||
ASSERT(comparator.comparator_number() <= m_comparators.size());
|
||||
VERIFY(comparator.comparator_number() <= m_comparators.size());
|
||||
Vector<unsigned> capable_interrupts;
|
||||
auto& comparator_registers = registers().timers[comparator.comparator_number()];
|
||||
u32 interrupt_bitfield = comparator_registers.interrupt_routing;
|
||||
|
|
@ -341,7 +341,7 @@ Vector<unsigned> HPET::capable_interrupt_numbers(const HPETComparator& comparato
|
|||
|
||||
Vector<unsigned> HPET::capable_interrupt_numbers(u8 comparator_number)
|
||||
{
|
||||
ASSERT(comparator_number <= m_comparators.size());
|
||||
VERIFY(comparator_number <= m_comparators.size());
|
||||
Vector<unsigned> capable_interrupts;
|
||||
auto& comparator_registers = registers().timers[comparator_number];
|
||||
u32 interrupt_bitfield = comparator_registers.interrupt_routing;
|
||||
|
|
@ -355,14 +355,14 @@ Vector<unsigned> HPET::capable_interrupt_numbers(u8 comparator_number)
|
|||
|
||||
void HPET::set_comparator_irq_vector(u8 comparator_number, u8 irq_vector)
|
||||
{
|
||||
ASSERT(comparator_number <= m_comparators.size());
|
||||
VERIFY(comparator_number <= m_comparators.size());
|
||||
auto& comparator_registers = registers().timers[comparator_number];
|
||||
comparator_registers.capabilities = comparator_registers.capabilities | (irq_vector << 9);
|
||||
}
|
||||
|
||||
bool HPET::is_periodic_capable(u8 comparator_number) const
|
||||
{
|
||||
ASSERT(comparator_number <= m_comparators.size());
|
||||
VERIFY(comparator_number <= m_comparators.size());
|
||||
auto& comparator_registers = registers().timers[comparator_number];
|
||||
return comparator_registers.capabilities & (u32)HPETFlags::TimerConfiguration::PeriodicInterruptCapable;
|
||||
}
|
||||
|
|
@ -370,13 +370,13 @@ bool HPET::is_periodic_capable(u8 comparator_number) const
|
|||
void HPET::set_comparators_to_optimal_interrupt_state(size_t)
|
||||
{
|
||||
// FIXME: Implement this method for allowing to use HPET timers 2-31...
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
PhysicalAddress HPET::find_acpi_hpet_registers_block()
|
||||
{
|
||||
auto sdt = map_typed<const volatile ACPI::Structures::HPET>(m_physical_acpi_hpet_table);
|
||||
ASSERT(sdt->event_timer_block.address_space == (u8)ACPI::GenericAddressStructure::AddressSpace::SystemMemory);
|
||||
VERIFY(sdt->event_timer_block.address_space == (u8)ACPI::GenericAddressStructure::AddressSpace::SystemMemory);
|
||||
return PhysicalAddress(sdt->event_timer_block.address);
|
||||
}
|
||||
|
||||
|
|
@ -418,13 +418,13 @@ UNMAP_AFTER_INIT HPET::HPET(PhysicalAddress acpi_hpet)
|
|||
bool capable_64_bit = regs.timers[i].capabilities & (u32)HPETFlags::TimerConfiguration::Timer64BitsCapable;
|
||||
klog() << "HPET: Timer[" << i << "] comparator size: " << (capable_64_bit ? "64 bit" : "32 bit") << " mode: " << ((!capable_64_bit || (regs.timers[i].capabilities & (u32)HPETFlags::TimerConfiguration::Force32BitMode)) ? "32 bit" : "64 bit");
|
||||
}
|
||||
ASSERT(timers_count >= 2);
|
||||
VERIFY(timers_count >= 2);
|
||||
|
||||
global_disable();
|
||||
|
||||
m_frequency = NANOSECOND_PERIOD_TO_HERTZ(calculate_ticks_in_nanoseconds());
|
||||
klog() << "HPET: frequency " << m_frequency << " Hz (" << MEGAHERTZ_TO_HERTZ(m_frequency) << " MHz) resolution: " << calculate_ticks_in_nanoseconds() << "ns";
|
||||
ASSERT(regs.capabilities.main_counter_tick_period <= ABSOLUTE_MAXIMUM_COUNTER_TICK_PERIOD);
|
||||
VERIFY(regs.capabilities.main_counter_tick_period <= ABSOLUTE_MAXIMUM_COUNTER_TICK_PERIOD);
|
||||
|
||||
// Reset the counter, just in case... (needs to match m_main_counter_last_read)
|
||||
regs.main_counter_value.high = 0;
|
||||
|
|
|
|||
|
|
@ -55,14 +55,14 @@ void HPETComparator::disable()
|
|||
|
||||
void HPETComparator::set_periodic()
|
||||
{
|
||||
ASSERT(m_periodic_capable);
|
||||
VERIFY(m_periodic_capable);
|
||||
m_periodic = true;
|
||||
m_enabled = true;
|
||||
HPET::the().enable_periodic_interrupt(*this);
|
||||
}
|
||||
void HPETComparator::set_non_periodic()
|
||||
{
|
||||
ASSERT(m_periodic_capable);
|
||||
VERIFY(m_periodic_capable);
|
||||
m_periodic = false;
|
||||
m_enabled = true;
|
||||
HPET::the().disable_periodic_interrupt(*this);
|
||||
|
|
@ -77,8 +77,8 @@ void HPETComparator::handle_irq(const RegisterState& regs)
|
|||
|
||||
void HPETComparator::set_new_countdown()
|
||||
{
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(m_frequency <= HPET::the().frequency());
|
||||
VERIFY_INTERRUPTS_DISABLED();
|
||||
VERIFY(m_frequency <= HPET::the().frequency());
|
||||
HPET::the().update_non_periodic_comparator_value(*this);
|
||||
}
|
||||
|
||||
|
|
@ -105,7 +105,7 @@ bool HPETComparator::try_to_set_frequency(size_t frequency)
|
|||
}
|
||||
|
||||
auto hpet_frequency = HPET::the().frequency();
|
||||
ASSERT(frequency <= hpet_frequency);
|
||||
VERIFY(frequency <= hpet_frequency);
|
||||
m_frequency = frequency;
|
||||
m_enabled = true;
|
||||
|
||||
|
|
|
|||
|
|
@ -66,19 +66,19 @@ size_t PIT::ticks_per_second() const
|
|||
void PIT::set_periodic()
|
||||
{
|
||||
// FIXME: Implement it...
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
void PIT::set_non_periodic()
|
||||
{
|
||||
// FIXME: Implement it...
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
void PIT::reset_to_default_ticks_per_second()
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
bool success = try_to_set_frequency(OPTIMAL_TICKS_PER_SECOND_RATE);
|
||||
ASSERT(success);
|
||||
VERIFY(success);
|
||||
}
|
||||
|
||||
bool PIT::try_to_set_frequency(size_t frequency)
|
||||
|
|
@ -96,12 +96,12 @@ bool PIT::try_to_set_frequency(size_t frequency)
|
|||
}
|
||||
bool PIT::is_capable_of_frequency(size_t frequency) const
|
||||
{
|
||||
ASSERT(frequency != 0);
|
||||
VERIFY(frequency != 0);
|
||||
return frequency <= BASE_FREQUENCY;
|
||||
}
|
||||
size_t PIT::calculate_nearest_possible_frequency(size_t frequency) const
|
||||
{
|
||||
ASSERT(frequency != 0);
|
||||
VERIFY(frequency != 0);
|
||||
return frequency;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ void RealTimeClock::reset_to_default_ticks_per_second()
|
|||
{
|
||||
InterruptDisabler disabler;
|
||||
bool success = try_to_set_frequency(1024);
|
||||
ASSERT(success);
|
||||
VERIFY(success);
|
||||
}
|
||||
|
||||
// FIXME: This is a quick & dirty log base 2 with a parameter. Please provide something better in the future.
|
||||
|
|
@ -91,7 +91,7 @@ bool RealTimeClock::try_to_set_frequency(size_t frequency)
|
|||
}
|
||||
bool RealTimeClock::is_capable_of_frequency(size_t frequency) const
|
||||
{
|
||||
ASSERT(frequency != 0);
|
||||
VERIFY(frequency != 0);
|
||||
if (frequency > MAX_FREQUENCY)
|
||||
return false;
|
||||
if (32768 % frequency)
|
||||
|
|
@ -102,7 +102,7 @@ bool RealTimeClock::is_capable_of_frequency(size_t frequency) const
|
|||
}
|
||||
size_t RealTimeClock::calculate_nearest_possible_frequency(size_t frequency) const
|
||||
{
|
||||
ASSERT(frequency != 0);
|
||||
VERIFY(frequency != 0);
|
||||
return frequency;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -118,10 +118,10 @@ timespec TimeManagement::monotonic_time(TimePrecision precision) const
|
|||
}
|
||||
} while (update_iteration != m_update2.load(AK::MemoryOrder::memory_order_acquire));
|
||||
|
||||
ASSERT(m_time_ticks_per_second > 0);
|
||||
ASSERT(ticks < m_time_ticks_per_second);
|
||||
VERIFY(m_time_ticks_per_second > 0);
|
||||
VERIFY(ticks < m_time_ticks_per_second);
|
||||
u64 ns = ((u64)ticks * 1000000000ull) / m_time_ticks_per_second;
|
||||
ASSERT(ns < 1000000000ull);
|
||||
VERIFY(ns < 1000000000ull);
|
||||
return { (long)seconds, (long)ns };
|
||||
}
|
||||
|
||||
|
|
@ -148,7 +148,7 @@ u64 TimeManagement::uptime_ms() const
|
|||
UNMAP_AFTER_INIT void TimeManagement::initialize(u32 cpu)
|
||||
{
|
||||
if (cpu == 0) {
|
||||
ASSERT(!s_the.is_initialized());
|
||||
VERIFY(!s_the.is_initialized());
|
||||
s_the.ensure_instance();
|
||||
|
||||
// Initialize the APIC timers after the other timers as the
|
||||
|
|
@ -160,7 +160,7 @@ UNMAP_AFTER_INIT void TimeManagement::initialize(u32 cpu)
|
|||
s_the->set_system_timer(*apic_timer);
|
||||
}
|
||||
} else {
|
||||
ASSERT(s_the.is_initialized());
|
||||
VERIFY(s_the.is_initialized());
|
||||
if (auto* apic_timer = APIC::the().get_timer()) {
|
||||
klog() << "Time: Enable APIC timer on CPU #" << cpu;
|
||||
apic_timer->enable_local_timer();
|
||||
|
|
@ -170,7 +170,7 @@ UNMAP_AFTER_INIT void TimeManagement::initialize(u32 cpu)
|
|||
|
||||
void TimeManagement::set_system_timer(HardwareTimerBase& timer)
|
||||
{
|
||||
ASSERT(Processor::id() == 0); // This should only be called on the BSP!
|
||||
VERIFY(Processor::id() == 0); // This should only be called on the BSP!
|
||||
auto original_callback = m_system_timer->set_callback(nullptr);
|
||||
m_system_timer->disable();
|
||||
timer.set_callback(move(original_callback));
|
||||
|
|
@ -205,9 +205,9 @@ UNMAP_AFTER_INIT TimeManagement::TimeManagement()
|
|||
if (probe_non_legacy_hardware_timers) {
|
||||
if (!probe_and_set_non_legacy_hardware_timers())
|
||||
if (!probe_and_set_legacy_hardware_timers())
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
} else if (!probe_and_set_legacy_hardware_timers()) {
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -252,7 +252,7 @@ bool TimeManagement::is_hpet_periodic_mode_allowed()
|
|||
return true;
|
||||
if (hpet_mode == "nonperiodic")
|
||||
return false;
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT bool TimeManagement::probe_and_set_non_legacy_hardware_timers()
|
||||
|
|
@ -274,9 +274,9 @@ UNMAP_AFTER_INIT bool TimeManagement::probe_and_set_non_legacy_hardware_timers()
|
|||
auto non_periodic_timers = scan_for_non_periodic_timers();
|
||||
|
||||
if (is_hpet_periodic_mode_allowed())
|
||||
ASSERT(!periodic_timers.is_empty());
|
||||
VERIFY(!periodic_timers.is_empty());
|
||||
|
||||
ASSERT(periodic_timers.size() + non_periodic_timers.size() > 0);
|
||||
VERIFY(periodic_timers.size() + non_periodic_timers.size() > 0);
|
||||
|
||||
if (periodic_timers.size() > 0)
|
||||
m_system_timer = periodic_timers[0];
|
||||
|
|
@ -337,8 +337,8 @@ void TimeManagement::update_time(const RegisterState&)
|
|||
|
||||
void TimeManagement::increment_time_since_boot_hpet()
|
||||
{
|
||||
ASSERT(!m_time_keeper_timer.is_null());
|
||||
ASSERT(m_time_keeper_timer->timer_type() == HardwareTimerType::HighPrecisionEventTimer);
|
||||
VERIFY(!m_time_keeper_timer.is_null());
|
||||
VERIFY(m_time_keeper_timer->timer_type() == HardwareTimerType::HighPrecisionEventTimer);
|
||||
|
||||
// NOTE: m_seconds_since_boot and m_ticks_this_second are only ever
|
||||
// updated here! So we can safely read that information, query the clock,
|
||||
|
|
@ -359,7 +359,7 @@ void TimeManagement::increment_time_since_boot_hpet()
|
|||
|
||||
void TimeManagement::increment_time_since_boot()
|
||||
{
|
||||
ASSERT(!m_time_keeper_timer.is_null());
|
||||
VERIFY(!m_time_keeper_timer.is_null());
|
||||
|
||||
// Compute time adjustment for adjtime. Let the clock run up to 1% fast or slow.
|
||||
// That way, adjtime can adjust up to 36 seconds per hour, without time getting very jumpy.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue