1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 20:17:44 +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 2021-02-23 20:42:32 +01:00
parent b33a6a443e
commit 5d180d1f99
725 changed files with 3448 additions and 3448 deletions

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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