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.

Kernel/TTY/ConsoleManagement.h

@@ -6,9 +6,9 @@
 
 #pragma once
 
-#include <AK/NonnullRefPtr.h>
-#include <AK/NonnullRefPtrVector.h>
 #include <AK/Types.h>
+#include <Kernel/Library/NonnullLockRefPtr.h>
+#include <Kernel/Library/NonnullLockRefPtrVector.h>
 #include <Kernel/TTY/VirtualConsole.h>
 
 namespace Kernel {
@@ -31,13 +31,13 @@ public:
 
     void switch_to_debug() { switch_to(1); }
 
-    NonnullRefPtr<VirtualConsole> first_tty() const { return m_consoles[0]; }
-    NonnullRefPtr<VirtualConsole> debug_tty() const { return m_consoles[1]; }
+    NonnullLockRefPtr<VirtualConsole> first_tty() const { return m_consoles[0]; }
+    NonnullLockRefPtr<VirtualConsole> debug_tty() const { return m_consoles[1]; }
 
     RecursiveSpinlock& tty_write_lock() { return m_tty_write_lock; }
 
 private:
-    NonnullRefPtrVector<VirtualConsole, s_max_virtual_consoles> m_consoles;
+    NonnullLockRefPtrVector<VirtualConsole, s_max_virtual_consoles> m_consoles;
     VirtualConsole* m_active_console { nullptr };
     Spinlock m_lock { LockRank::None };
     RecursiveSpinlock m_tty_write_lock { LockRank::None };

Kernel/TTY/MasterPTY.cpp

@@ -16,11 +16,11 @@
 
 namespace Kernel {
 
-ErrorOr<NonnullRefPtr<MasterPTY>> MasterPTY::try_create(unsigned int index)
+ErrorOr<NonnullLockRefPtr<MasterPTY>> MasterPTY::try_create(unsigned int index)
 {
     auto buffer = TRY(DoubleBuffer::try_create("MasterPTY: Buffer"sv));
-    auto master_pty = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) MasterPTY(index, move(buffer))));
-    auto slave_pty = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) SlavePTY(*master_pty, index)));
+    auto master_pty = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) MasterPTY(index, move(buffer))));
+    auto slave_pty = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) SlavePTY(*master_pty, index)));
     master_pty->m_slave = slave_pty;
     master_pty->after_inserting();
     slave_pty->after_inserting();

Kernel/TTY/MasterPTY.h

@@ -16,7 +16,7 @@ class SlavePTY;
 
 class MasterPTY final : public CharacterDevice {
 public:
-    static ErrorOr<NonnullRefPtr<MasterPTY>> try_create(unsigned index);
+    static ErrorOr<NonnullLockRefPtr<MasterPTY>> try_create(unsigned index);
     virtual ~MasterPTY() override;
 
     unsigned index() const { return m_index; }
@@ -39,7 +39,7 @@ private:
     virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
     virtual StringView class_name() const override { return "MasterPTY"sv; }
 
-    RefPtr<SlavePTY> m_slave;
+    LockRefPtr<SlavePTY> m_slave;
     unsigned m_index;
     bool m_closed { false };
     NonnullOwnPtr<DoubleBuffer> m_buffer;

Kernel/TTY/PTYMultiplexer.cpp

@@ -38,9 +38,9 @@ UNMAP_AFTER_INIT void PTYMultiplexer::initialize()
     the().after_inserting();
 }
 
-ErrorOr<NonnullRefPtr<OpenFileDescription>> PTYMultiplexer::open(int options)
+ErrorOr<NonnullLockRefPtr<OpenFileDescription>> PTYMultiplexer::open(int options)
 {
-    return m_freelist.with([&](auto& freelist) -> ErrorOr<NonnullRefPtr<OpenFileDescription>> {
+    return m_freelist.with([&](auto& freelist) -> ErrorOr<NonnullLockRefPtr<OpenFileDescription>> {
         if (freelist.is_empty())
             return EBUSY;
 

Kernel/TTY/PTYMultiplexer.h

@@ -22,7 +22,7 @@ public:
     static PTYMultiplexer& the();
 
     // ^CharacterDevice
-    virtual ErrorOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
+    virtual ErrorOr<NonnullLockRefPtr<OpenFileDescription>> open(int options) override;
     virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return 0; }
     virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override { return 0; }
     virtual bool can_read(OpenFileDescription const&, u64) const override { return true; }

Kernel/TTY/SlavePTY.h

@@ -41,7 +41,7 @@ private:
     friend class MasterPTY;
     SlavePTY(MasterPTY&, unsigned index);
 
-    RefPtr<MasterPTY> m_master;
+    LockRefPtr<MasterPTY> m_master;
     time_t m_time_of_last_write { 0 };
     unsigned m_index { 0 };
 

Kernel/TTY/TTY.h

@@ -7,9 +7,9 @@
 #pragma once
 
 #include <AK/CircularDeque.h>
-#include <AK/WeakPtr.h>
 #include <Kernel/Devices/CharacterDevice.h>
 #include <Kernel/DoubleBuffer.h>
+#include <Kernel/Library/LockWeakPtr.h>
 #include <Kernel/ProcessGroup.h>
 #include <Kernel/UnixTypes.h>
 
@@ -89,8 +89,8 @@ private:
     // FIXME: use something like AK::Bitmap but which takes a size template parameter
     u8 m_special_character_bitmask[TTY_BUFFER_SIZE / 8];
 
-    WeakPtr<Process> m_original_process_parent;
-    WeakPtr<ProcessGroup> m_pg;
+    LockWeakPtr<Process> m_original_process_parent;
+    LockWeakPtr<ProcessGroup> m_pg;
     termios m_termios;
     unsigned short m_rows { 0 };
     unsigned short m_columns { 0 };

Kernel/TTY/VirtualConsole.cpp

@@ -107,7 +107,7 @@ ErrorOr<NonnullOwnPtr<KString>> VirtualConsole::pseudo_name() const
     return KString::formatted("tty:{}", m_index);
 }
 
-UNMAP_AFTER_INIT NonnullRefPtr<VirtualConsole> VirtualConsole::create(size_t index)
+UNMAP_AFTER_INIT NonnullLockRefPtr<VirtualConsole> VirtualConsole::create(size_t index)
 {
     auto virtual_console_or_error = DeviceManagement::try_create_device<VirtualConsole>(index);
     // FIXME: Find a way to propagate errors
@@ -115,7 +115,7 @@ UNMAP_AFTER_INIT NonnullRefPtr<VirtualConsole> VirtualConsole::create(size_t ind
     return virtual_console_or_error.release_value();
 }
 
-UNMAP_AFTER_INIT NonnullRefPtr<VirtualConsole> VirtualConsole::create_with_preset_log(size_t index, CircularQueue<char, 16384> const& log)
+UNMAP_AFTER_INIT NonnullLockRefPtr<VirtualConsole> VirtualConsole::create_with_preset_log(size_t index, CircularQueue<char, 16384> const& log)
 {
     auto virtual_console = VirtualConsole::create(index);
     // HACK: We have to go through the TTY layer for correct newline handling.

Kernel/TTY/VirtualConsole.h

@@ -69,8 +69,8 @@ public:
     };
 
 public:
-    static NonnullRefPtr<VirtualConsole> create(size_t index);
-    static NonnullRefPtr<VirtualConsole> create_with_preset_log(size_t index, CircularQueue<char, 16384> const&);
+    static NonnullLockRefPtr<VirtualConsole> create(size_t index);
+    static NonnullLockRefPtr<VirtualConsole> create_with_preset_log(size_t index, CircularQueue<char, 16384> const&);
 
     virtual ~VirtualConsole() override;