RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 09:17:35 +00:00
Code Issues Activity Actions

Kernel: Make self-contained locking smart pointers their own classes

Browse source 
Until now, our kernel has reimplemented a number of AK classes to
provide automatic internal locking:

- RefPtr
- NonnullRefPtr
- WeakPtr
- Weakable

This patch renames the Kernel classes so that they can coexist with
the original AK classes:

- RefPtr => LockRefPtr
- NonnullRefPtr => NonnullLockRefPtr
- WeakPtr => LockWeakPtr
- Weakable => LockWeakable

The goal here is to eventually get rid of the Lock* classes in favor of
using external locking.
This commit is contained in:
Andreas Kling 2022-08-19 20:53:40 +02:00
parent e475263113
commit 11eee67b85
360 changed files with 1703 additions and 1672 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Time/APICTimer.cpp
View file

@ -16,7 +16,7 @@ namespace Kernel {
UNMAP_AFTER_INIT APICTimer* APICTimer::initialize(u8 interrupt_number, HardwareTimerBase& calibration_source)
{
auto timer = adopt_ref(*new APICTimer(interrupt_number, nullptr));
auto timer = adopt_lock_ref(*new APICTimer(interrupt_number, nullptr));
timer->register_interrupt_handler();
if (!timer->calibrate(calibration_source)) {
return nullptr;

6
Kernel/Time/HPET.h
View file

@ -6,10 +6,10 @@
#pragma once
#include <AK/NonnullRefPtrVector.h>
#include <AK/OwnPtr.h>
#include <AK/Types.h>
#include <AK/Vector.h>
#include <Kernel/Library/NonnullLockRefPtrVector.h>
#include <Kernel/Memory/Region.h>
#include <Kernel/PhysicalAddress.h>
@ -29,7 +29,7 @@ public:
u64 raw_counter_ticks_to_ns(u64) const;
u64 ns_to_raw_counter_ticks(u64) const;
NonnullRefPtrVector<HPETComparator> const& comparators() const { return m_comparators; }
NonnullLockRefPtrVector<HPETComparator> const& comparators() const { return m_comparators; }
void disable(HPETComparator const&);
void enable(HPETComparator const&);
@ -78,6 +78,6 @@ private:
bool m_main_counter_64bits : 1;
bool legacy_replacement_route_capable : 1;
NonnullRefPtrVector<HPETComparator> m_comparators;
NonnullLockRefPtrVector<HPETComparator> m_comparators;
};
}

4
Kernel/Time/HPETComparator.cpp
View file

@ -13,9 +13,9 @@
namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<HPETComparator> HPETComparator::create(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable)
UNMAP_AFTER_INIT NonnullLockRefPtr<HPETComparator> HPETComparator::create(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable)
{
auto timer = adopt_ref(*new HPETComparator(number, irq, periodic_capable, is_64bit_capable));
auto timer = adopt_lock_ref(*new HPETComparator(number, irq, periodic_capable, is_64bit_capable));
timer->register_interrupt_handler();
return timer;
}

2
Kernel/Time/HPETComparator.h
View file

@ -16,7 +16,7 @@ class HPETComparator final : public HardwareTimer<IRQHandler> {
friend class HPET;
public:
static NonnullRefPtr<HPETComparator> create(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable);
static NonnullLockRefPtr<HPETComparator> create(u8 number, u8 irq, bool periodic_capable, bool is_64bit_capable);
virtual HardwareTimerType timer_type() const override { return HardwareTimerType::HighPrecisionEventTimer; }
virtual StringView model() const override { return "HPET"sv; }

4
Kernel/Time/PIT.cpp
View file

@ -16,9 +16,9 @@
#define IRQ_TIMER 0
namespace Kernel {
UNMAP_AFTER_INIT NonnullRefPtr<PIT> PIT::initialize(Function<void(RegisterState const&)> callback)
UNMAP_AFTER_INIT NonnullLockRefPtr<PIT> PIT::initialize(Function<void(RegisterState const&)> callback)
{
return adopt_ref(*new PIT(move(callback)));
return adopt_lock_ref(*new PIT(move(callback)));
}
[[maybe_unused]] inline static void reset_countdown(u16 timer_reload)

4
Kernel/Time/PIT.h
View file

@ -6,8 +6,8 @@
#pragma once
#include <AK/NonnullRefPtr.h>
#include <AK/Types.h>
#include <Kernel/Library/NonnullLockRefPtr.h>
#include <Kernel/Time/HardwareTimer.h>
namespace Kernel {
@ -34,7 +34,7 @@ namespace Kernel {
class PIT final : public HardwareTimer<IRQHandler> {
public:
static NonnullRefPtr<PIT> initialize(Function<void(RegisterState const&)>);
static NonnullLockRefPtr<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;

4
Kernel/Time/RTC.cpp
View file

@ -15,9 +15,9 @@ namespace Kernel {
#define IRQ_TIMER 8
#define MAX_FREQUENCY 8000
NonnullRefPtr<RealTimeClock> RealTimeClock::create(Function<void(RegisterState const&)> callback)
NonnullLockRefPtr<RealTimeClock> RealTimeClock::create(Function<void(RegisterState const&)> callback)
{
return adopt_ref(*new RealTimeClock(move(callback)));
return adopt_lock_ref(*new RealTimeClock(move(callback)));
}
RealTimeClock::RealTimeClock(Function<void(RegisterState const&)> callback)
: HardwareTimer(IRQ_TIMER, move(callback))

4
Kernel/Time/RTC.h
View file

@ -6,14 +6,14 @@
#pragma once
#include <AK/NonnullRefPtr.h>
#include <Kernel/Library/NonnullLockRefPtr.h>
#include <Kernel/RTC.h>
#include <Kernel/Time/HardwareTimer.h>
namespace Kernel {
class RealTimeClock final : public HardwareTimer<IRQHandler> {
public:
static NonnullRefPtr<RealTimeClock> create(Function<void(RegisterState const&)> callback);
static NonnullLockRefPtr<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;

12
Kernel/Time/TimeManagement.h
View file

@ -7,13 +7,13 @@
#pragma once
#include <AK/Error.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/OwnPtr.h>
#include <AK/RefPtr.h>
#include <AK/Time.h>
#include <AK/Types.h>
#include <Kernel/API/TimePage.h>
#include <Kernel/Arch/RegisterState.h>
#include <Kernel/Library/LockRefPtr.h>
#include <Kernel/Library/NonnullLockRefPtrVector.h>
#include <Kernel/UnixTypes.h>
namespace Kernel {
@ -83,7 +83,7 @@ private:
bool probe_and_set_non_legacy_hardware_timers();
Vector<HardwareTimerBase*> scan_and_initialize_periodic_timers();
Vector<HardwareTimerBase*> scan_for_non_periodic_timers();
NonnullRefPtrVector<HardwareTimerBase> m_hardware_timers;
NonnullLockRefPtrVector<HardwareTimerBase> m_hardware_timers;
void set_system_timer(HardwareTimerBase&);
static void system_timer_tick(RegisterState const&);
@ -102,11 +102,11 @@ private:
bool m_can_query_precise_time { false };
bool m_updating_time { false }; // may only be accessed from the BSP!
RefPtr<HardwareTimerBase> m_system_timer;
RefPtr<HardwareTimerBase> m_time_keeper_timer;
LockRefPtr<HardwareTimerBase> m_system_timer;
LockRefPtr<HardwareTimerBase> m_time_keeper_timer;
Atomic<u32> m_profile_enable_count { 0 };
RefPtr<HardwareTimerBase> m_profile_timer;
LockRefPtr<HardwareTimerBase> m_profile_timer;
NonnullOwnPtr<Memory::Region> m_time_page_region;
};