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

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.

9 files changed, 21 insertions, 21 deletions

diff --git a/Kernel/Time/APICTimer.cpp b/Kernel/Time/APICTimer.cpp
index 4131627d24..ae8507c67e 100644
--- a/Kernel/Time/APICTimer.cpp
+++ b/Kernel/Time/APICTimer.cpp
@@ -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;
diff --git a/Kernel/Time/HPET.h b/Kernel/Time/HPET.h
index 799c3439d9..8454985774 100644
--- a/Kernel/Time/HPET.h
+++ b/Kernel/Time/HPET.h
@@ -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;
 };
 }
diff --git a/Kernel/Time/HPETComparator.cpp b/Kernel/Time/HPETComparator.cpp
index 7cdefd1706..6d4a3aea73 100644
--- a/Kernel/Time/HPETComparator.cpp
+++ b/Kernel/Time/HPETComparator.cpp
@@ -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;
 }
diff --git a/Kernel/Time/HPETComparator.h b/Kernel/Time/HPETComparator.h
index 584c0499be..2bbbfcb709 100644
--- a/Kernel/Time/HPETComparator.h
+++ b/Kernel/Time/HPETComparator.h
@@ -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; }
diff --git a/Kernel/Time/PIT.cpp b/Kernel/Time/PIT.cpp
index f435e23b5c..d2796fb8f6 100644
--- a/Kernel/Time/PIT.cpp
+++ b/Kernel/Time/PIT.cpp
@@ -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)
diff --git a/Kernel/Time/PIT.h b/Kernel/Time/PIT.h
index 081ecb9523..552a638acd 100644
--- a/Kernel/Time/PIT.h
+++ b/Kernel/Time/PIT.h
@@ -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;
diff --git a/Kernel/Time/RTC.cpp b/Kernel/Time/RTC.cpp
index 59de79808e..8d9fbe897f 100644
--- a/Kernel/Time/RTC.cpp
+++ b/Kernel/Time/RTC.cpp
@@ -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))
diff --git a/Kernel/Time/RTC.h b/Kernel/Time/RTC.h
index c0b3ab4c7b..a63cef27f6 100644
--- a/Kernel/Time/RTC.h
+++ b/Kernel/Time/RTC.h
@@ -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;
diff --git a/Kernel/Time/TimeManagement.h b/Kernel/Time/TimeManagement.h
index 9d1735e101..967c4eec88 100644
--- a/Kernel/Time/TimeManagement.h
+++ b/Kernel/Time/TimeManagement.h
@@ -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;
 };