Kernel: Switch singletons to use new Singleton class

Fixes #3226

Kernel/Console.cpp

@@ -27,29 +27,33 @@
 #include <Kernel/Console.h>
 #include <Kernel/IO.h>
 #include <Kernel/kstdio.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/SpinLock.h>
 
 // Bytes output to 0xE9 end up on the Bochs console. It's very handy.
 #define CONSOLE_OUT_TO_E9
 
-static Console* s_the;
+static auto s_the = Kernel::make_singleton<Console>();
 static Kernel::SpinLock g_console_lock;
 
+void Console::initialize()
+{
+    s_the.ensure_instance();
+}
+
 Console& Console::the()
 {
-    ASSERT(s_the);
     return *s_the;
 }
 
 bool Console::is_initialized()
 {
-    return s_the != nullptr;
+    return s_the.is_initialized();
 }
 
 Console::Console()
     : CharacterDevice(5, 1)
 {
-    s_the = this;
 }
 
 Console::~Console()

Kernel/Console.h

@@ -34,6 +34,7 @@ class Console final : public Kernel::CharacterDevice {
     AK_MAKE_ETERNAL
 public:
     static Console& the();
+    static void initialize();
     static bool is_initialized();
 
     Console();

Kernel/Devices/BXVGADevice.cpp

@@ -29,6 +29,7 @@
 #include <Kernel/IO.h>
 #include <Kernel/PCI/Access.h>
 #include <Kernel/Process.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/VM/AnonymousVMObject.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <LibC/errno_numbers.h>
@@ -56,7 +57,12 @@ namespace Kernel {
 #define VBE_DISPI_ENABLED 0x01
 #define VBE_DISPI_LFB_ENABLED 0x40
 
-static BXVGADevice* s_the;
+static auto s_the = make_singleton<BXVGADevice>();
+
+void BXVGADevice::initialize()
+{
+    s_the.ensure_instance();
+}
 
 BXVGADevice& BXVGADevice::the()
 {
@@ -67,7 +73,6 @@ BXVGADevice::BXVGADevice()
     : BlockDevice(29, 0)
 
 {
-    s_the = this;
     m_framebuffer_address = PhysicalAddress(find_framebuffer_address());
     set_safe_resolution();
 }

Kernel/Devices/BXVGADevice.h

@@ -36,6 +36,7 @@ namespace Kernel {
 class BXVGADevice final : public BlockDevice {
     AK_MAKE_ETERNAL
 public:
+    static void initialize();
     static BXVGADevice& the();
 
     BXVGADevice();

Kernel/Devices/Device.cpp

@@ -26,16 +26,15 @@
 
 #include <Kernel/Devices/Device.h>
 #include <Kernel/FileSystem/InodeMetadata.h>
+#include <Kernel/Singleton.h>
 #include <LibC/errno_numbers.h>
 
 namespace Kernel {
 
-static HashMap<u32, Device*>* s_all_devices;
+static auto s_all_devices = make_singleton<HashMap<u32, Device*>>();
 
 HashMap<u32, Device*>& Device::all_devices()
 {
-    if (s_all_devices == nullptr)
-        s_all_devices = new HashMap<u32, Device*>;
     return *s_all_devices;
 }
 

Kernel/Devices/KeyboardDevice.cpp

@@ -31,6 +31,7 @@
 #include <Kernel/Arch/i386/CPU.h>
 #include <Kernel/Devices/KeyboardDevice.h>
 #include <Kernel/IO.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/TTY/VirtualConsole.h>
 
 //#define KEYBOARD_DEBUG
@@ -335,11 +336,15 @@ void KeyboardDevice::handle_irq(const RegisterState&)
     }
 }
 
-static KeyboardDevice* s_the;
+static auto s_the = make_singleton<KeyboardDevice>();
+
+void KeyboardDevice::initialize()
+{
+    s_the.ensure_instance();
+}
 
 KeyboardDevice& KeyboardDevice::the()
 {
-    ASSERT(s_the);
     return *s_the;
 }
 
@@ -347,8 +352,6 @@ KeyboardDevice::KeyboardDevice()
     : IRQHandler(IRQ_KEYBOARD)
     , CharacterDevice(85, 1)
 {
-    s_the = this;
-
     // Empty the buffer of any pending data.
     // I don't care what you've been pressing until now!
     while (IO::in8(I8042_STATUS) & I8042_BUFFER_FULL)

Kernel/Devices/KeyboardDevice.h

@@ -45,6 +45,7 @@ class KeyboardDevice final : public IRQHandler
 public:
     using Event = KeyEvent;
 
+    static void initialize();
     static KeyboardDevice& the();
 
     virtual ~KeyboardDevice() override;

Kernel/Devices/NullDevice.cpp

@@ -26,21 +26,25 @@
 
 #include "NullDevice.h"
 #include <AK/StdLibExtras.h>
+#include <Kernel/Singleton.h>
 
 namespace Kernel {
 
-static NullDevice* s_the;
+static auto s_the = make_singleton<NullDevice>();
+
+void NullDevice::initialize()
+{
+    s_the.ensure_instance();
+}
 
 NullDevice& NullDevice::the()
 {
-    ASSERT(s_the);
     return *s_the;
 }
 
 NullDevice::NullDevice()
     : CharacterDevice(1, 3)
 {
-    s_the = this;
 }
 
 NullDevice::~NullDevice()

Kernel/Devices/NullDevice.h

@@ -36,6 +36,7 @@ public:
     NullDevice();
     virtual ~NullDevice() override;
 
+    static void initialize();
     static NullDevice& the();
 
 private:

Kernel/Devices/PATAChannel.cpp

@@ -31,6 +31,7 @@
 #include <Kernel/FileSystem/ProcFS.h>
 #include <Kernel/IO.h>
 #include <Kernel/Process.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/VM/MemoryManager.h>
 
 namespace Kernel {
@@ -106,13 +107,12 @@ namespace Kernel {
 
 #define PCI_Mass_Storage_Class 0x1
 #define PCI_IDE_Controller_Subclass 0x1
+
+static auto s_pata_lock = make_singleton<Lock>();
+
 static Lock& s_lock()
 {
-    static Lock* lock;
-    if (!lock)
-        lock = new Lock;
-
-    return *lock;
+    return *s_pata_lock;
 };
 
 OwnPtr<PATAChannel> PATAChannel::create(ChannelType type, bool force_pio)

Kernel/Devices/PS2MouseDevice.cpp

@@ -28,6 +28,7 @@
 #include <Kernel/Devices/PS2MouseDevice.h>
 #include <Kernel/Devices/VMWareBackdoor.h>
 #include <Kernel/IO.h>
+#include <Kernel/Singleton.h>
 
 namespace Kernel {
 
@@ -56,13 +57,12 @@ namespace Kernel {
 
 //#define PS2MOUSE_DEBUG
 
-static PS2MouseDevice* s_the;
+static auto s_the = make_singleton<PS2MouseDevice>();
 
 PS2MouseDevice::PS2MouseDevice()
     : IRQHandler(IRQ_MOUSE)
     , CharacterDevice(10, 1)
 {
-    s_the = this;
     initialize();
 }
 
@@ -70,6 +70,11 @@ PS2MouseDevice::~PS2MouseDevice()
 {
 }
 
+void PS2MouseDevice::create()
+{
+   s_the.ensure_instance();
+}
+
 PS2MouseDevice& PS2MouseDevice::the()
 {
     return *s_the;

Kernel/Devices/PS2MouseDevice.h

@@ -40,6 +40,7 @@ public:
     PS2MouseDevice();
     virtual ~PS2MouseDevice() override;
 
+    static void create();
     static PS2MouseDevice& the();
 
     // ^CharacterDevice

Kernel/Devices/SB16.cpp

@@ -31,6 +31,7 @@
 #include <Kernel/VM/AnonymousVMObject.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <Kernel/IO.h>
+#include <Kernel/Singleton.h>
 
 //#define SB16_DEBUG
 
@@ -76,13 +77,12 @@ void SB16::set_sample_rate(uint16_t hz)
     dsp_write((u8)hz);
 }
 
-static SB16* s_the;
+static auto s_the = make_singleton<SB16>();
 
 SB16::SB16()
     : IRQHandler(SB16_DEFAULT_IRQ)
     , CharacterDevice(42, 42) // ### ?
 {
-    s_the = this;
     initialize();
 }
 
@@ -90,6 +90,11 @@ SB16::~SB16()
 {
 }
 
+void SB16::create()
+{
+    s_the.ensure_instance();
+}
+
 SB16& SB16::the()
 {
     return *s_the;

Kernel/Devices/SB16.h

@@ -42,6 +42,7 @@ public:
     SB16();
     virtual ~SB16() override;
 
+    static void create();
     static SB16& the();
 
     // ^CharacterDevice

Kernel/Devices/VMWareBackdoor.cpp

@@ -25,12 +25,14 @@
  */
 
 #include <AK/Assertions.h>
+#include <AK/OwnPtr.h>
 #include <AK/String.h>
 #include <Kernel/Arch/i386/CPU.h>
 #include <Kernel/CommandLine.h>
 #include <Kernel/Devices/VMWareBackdoor.h>
 #include <Kernel/API/MousePacket.h>
 #include <Kernel/IO.h>
+#include <Kernel/Singleton.h>
 
 namespace Kernel {
 
@@ -80,8 +82,21 @@ inline void vmware_high_bandwidth_get(VMWareCommand& command)
                  : "+a"(command.ax), "+b"(command.bx), "+c"(command.cx), "+d"(command.dx), "+S"(command.si), "+D"(command.di));
 }
 
-static VMWareBackdoor* s_vmware_backdoor;
+class VMWareBackdoorDetector
+{
+public:
+    VMWareBackdoorDetector()
+    {
+        if (detect_presence())
+            m_backdoor = make<VMWareBackdoor>();
+    }
 
+    VMWareBackdoor* get_instance()
+    {
+        return m_backdoor.ptr();
+    }
+
+private:
     static bool detect_presence()
     {
         VMWareCommand command;
@@ -93,20 +108,14 @@ static bool detect_presence()
         return true;
     }
 
-VMWareBackdoor* VMWareBackdoor::initialize()
-{
-    ASSERT(s_vmware_backdoor == nullptr);
-    if (!detect_presence())
-        return nullptr;
+    OwnPtr<VMWareBackdoor> m_backdoor;
+};
 
-    s_vmware_backdoor = new VMWareBackdoor;
-    klog() << "VMWare backdoor opened.";
-    return s_vmware_backdoor;
-}
+static auto s_vmware_backdoor = make_singleton<VMWareBackdoorDetector>();
 
 VMWareBackdoor* VMWareBackdoor::the()
 {
-    return s_vmware_backdoor;
+    return s_vmware_backdoor->get_instance();
 }
 
 VMWareBackdoor::VMWareBackdoor()

Kernel/Devices/VMWareBackdoor.h

@@ -63,9 +63,9 @@ class VMWareBackdoor {
     AK_MAKE_ETERNAL;
 
 public:
+    VMWareBackdoor();
     static VMWareBackdoor* the();
 
-    static VMWareBackdoor* initialize();
     bool vmmouse_is_absolute() const;
     void enable_absolute_vmmouse();
     void disable_absolute_vmmouse();
@@ -76,7 +76,6 @@ public:
 private:
     void send_high_bandwidth(VMWareCommand& command);
     void get_high_bandwidth(VMWareCommand& command);
-    VMWareBackdoor();
     bool detect_vmmouse();
     bool m_vmmouse_absolute { false };
 };

Kernel/FileSystem/DevPtsFS.cpp

@@ -28,6 +28,7 @@
 #include <AK/StringView.h>
 #include <Kernel/FileSystem/DevPtsFS.h>
 #include <Kernel/FileSystem/VirtualFileSystem.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/TTY/SlavePTY.h>
 
 namespace Kernel {
@@ -45,14 +46,10 @@ DevPtsFS::~DevPtsFS()
 {
 }
 
-static HashTable<unsigned>* ptys;
+static auto s_ptys = make_singleton<HashTable<unsigned>>();
 
 bool DevPtsFS::initialize()
 {
-    if (ptys == nullptr) {
-        ptys = new HashTable<unsigned>();
-    }
-
     m_root_inode = adopt(*new DevPtsFSInode(*this, 1));
     m_root_inode->m_metadata.inode = { fsid(), 1 };
     m_root_inode->m_metadata.mode = 0040555;
@@ -104,12 +101,12 @@ RefPtr<Inode> DevPtsFS::get_inode(InodeIdentifier inode_id) const
 
 void DevPtsFS::register_slave_pty(SlavePTY& slave_pty)
 {
-    ptys->set(slave_pty.index());
+    s_ptys->set(slave_pty.index());
 }
 
 void DevPtsFS::unregister_slave_pty(SlavePTY& slave_pty)
 {
-    ptys->remove(slave_pty.index());
+    s_ptys->remove(slave_pty.index());
 }
 
 DevPtsFSInode::DevPtsFSInode(DevPtsFS& fs, unsigned index)
@@ -144,7 +141,7 @@ KResult DevPtsFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEn
     callback({ ".", identifier(), 0 });
     callback({ "..", identifier(), 0 });
 
-    for (unsigned pty_index : *ptys) {
+    for (unsigned pty_index : *s_ptys) {
         String name = String::number(pty_index);
         InodeIdentifier identifier = { fsid(), pty_index_to_inode_index(pty_index) };
         callback({ name, identifier, 0 });
@@ -157,7 +154,7 @@ KResultOr<size_t> DevPtsFSInode::directory_entry_count() const
 {
     ASSERT(identifier().index() == 1);
 
-    return 2 + ptys->size();
+    return 2 + s_ptys->size();
 }
 
 RefPtr<Inode> DevPtsFSInode::lookup(StringView name)
@@ -170,7 +167,7 @@ RefPtr<Inode> DevPtsFSInode::lookup(StringView name)
     auto& fs = static_cast<DevPtsFS&>(this->fs());
 
     auto pty_index = name.to_uint();
-    if (pty_index.has_value() && ptys->contains(pty_index.value())) {
+    if (pty_index.has_value() && s_ptys->contains(pty_index.value())) {
         return fs.get_inode({ fsid(), pty_index_to_inode_index(pty_index.value()) });
     }
 

Kernel/FileSystem/FIFO.cpp

@@ -31,17 +31,17 @@
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/Lock.h>
 #include <Kernel/Process.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/Thread.h>
 
 //#define FIFO_DEBUG
 
 namespace Kernel {
 
+static auto s_table = make_singleton<Lockable<HashTable<FIFO*>>>();
+
 static Lockable<HashTable<FIFO*>>& all_fifos()
 {
-    static Lockable<HashTable<FIFO*>>* s_table;
-    if (!s_table)
-        s_table = new Lockable<HashTable<FIFO*>>;
     return *s_table;
 }
 

Kernel/FileSystem/FileSystem.cpp

@@ -31,18 +31,17 @@
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/Net/LocalSocket.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <LibC/errno_numbers.h>
 
 namespace Kernel {
 
 static u32 s_lastFileSystemID;
-static HashMap<u32, FS*>* s_fs_map;
+static auto s_fs_map = make_singleton<HashMap<u32, FS*>>();
 
 static HashMap<u32, FS*>& all_fses()
 {
-    if (!s_fs_map)
-        s_fs_map = new HashMap<u32, FS*>();
     return *s_fs_map;
 }
 

Kernel/FileSystem/Inode.cpp

@@ -33,20 +33,19 @@
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/KBufferBuilder.h>
 #include <Kernel/Net/LocalSocket.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/VM/SharedInodeVMObject.h>
 
 namespace Kernel {
 
 static SpinLock s_all_inodes_lock;
+static auto s_list = make_singleton<InlineLinkedList<Inode>>();
 
 InlineLinkedList<Inode>& Inode::all_with_lock()
 {
     ASSERT(s_all_inodes_lock.is_locked());
 
-    static InlineLinkedList<Inode>* list;
-    if (!list)
-        list = new InlineLinkedList<Inode>;
-    return *list;
+    return *s_list;
 }
 
 void Inode::sync()

Kernel/FileSystem/VirtualFileSystem.cpp

@@ -34,19 +34,24 @@
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/KSyms.h>
 #include <Kernel/Process.h>
+#include <Kernel/Singleton.h>
 #include <LibC/errno_numbers.h>
 
 //#define VFS_DEBUG
 
 namespace Kernel {
 
-static VFS* s_the;
+static auto s_the = make_singleton<VFS>();
 static constexpr int symlink_recursion_limit { 5 }; // FIXME: increase?
 static constexpr int root_mount_flags = MS_NODEV | MS_NOSUID | MS_RDONLY;
 
+void VFS::initialize()
+{
+    s_the.ensure_instance();
+}
+
 VFS& VFS::the()
 {
-    ASSERT(s_the);
     return *s_the;
 }
 
@@ -55,7 +60,6 @@ VFS::VFS()
 #ifdef VFS_DEBUG
     klog() << "VFS: Constructing VFS";
 #endif
-    s_the = this;
 }
 
 VFS::~VFS()

Kernel/FileSystem/VirtualFileSystem.h

@@ -78,6 +78,7 @@ public:
         int m_flags;
     };
 
+    static void initialize();
     static VFS& the();
 
     VFS();

Kernel/Interrupts/APIC.cpp

@@ -34,6 +34,7 @@
 #include <Kernel/IO.h>
 #include <Kernel/Interrupts/APIC.h>
 #include <Kernel/Interrupts/SpuriousInterruptHandler.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/Thread.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <Kernel/VM/PageDirectory.h>
@@ -68,7 +69,7 @@
 
 namespace Kernel {
 
-static APIC* s_apic;
+static auto s_apic = make_singleton<APIC>();
 
 class APICIPIInterruptHandler final : public GenericInterruptHandler {
 public:
@@ -132,7 +133,7 @@ private:
 
 bool APIC::initialized()
 {
-    return (s_apic != nullptr);
+    return s_apic.is_initialized();
 }
 
 APIC& APIC::the()
@@ -144,7 +145,7 @@ APIC& APIC::the()
 void APIC::initialize()
 {
     ASSERT(!APIC::initialized());
-    s_apic = new APIC();
+    s_apic.ensure_instance();
 }
 
 PhysicalAddress APIC::get_base()

Kernel/Net/IPv4Socket.cpp

@@ -25,6 +25,7 @@
  */
 
 #include <AK/StringBuilder.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/Net/ARP.h>
 #include <Kernel/Net/ICMP.h>
@@ -45,11 +46,10 @@
 
 namespace Kernel {
 
+static auto s_table = make_singleton<Lockable<HashTable<IPv4Socket*>>>();
+
 Lockable<HashTable<IPv4Socket*>>& IPv4Socket::all_sockets()
 {
-    static Lockable<HashTable<IPv4Socket*>>* s_table;
-    if (!s_table)
-        s_table = new Lockable<HashTable<IPv4Socket*>>;
     return *s_table;
 }
 

Kernel/Net/LocalSocket.cpp

@@ -29,6 +29,7 @@
 #include <Kernel/FileSystem/VirtualFileSystem.h>
 #include <Kernel/Net/LocalSocket.h>
 #include <Kernel/Process.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/StdLib.h>
 #include <Kernel/UnixTypes.h>
 #include <LibC/errno_numbers.h>
@@ -37,11 +38,10 @@
 
 namespace Kernel {
 
+static auto s_list = make_singleton<Lockable<InlineLinkedList<LocalSocket>>>();
+
 Lockable<InlineLinkedList<LocalSocket>>& LocalSocket::all_sockets()
 {
-    static Lockable<InlineLinkedList<LocalSocket>>* s_list;
-    if (!s_list)
-        s_list = new Lockable<InlineLinkedList<LocalSocket>>();
     return *s_list;
 }
 

Kernel/Net/LoopbackAdapter.cpp

@@ -25,15 +25,15 @@
  */
 
 #include <Kernel/Net/LoopbackAdapter.h>
+#include <Kernel/Singleton.h>
 
 namespace Kernel {
 
+static auto s_loopback = make_singleton<LoopbackAdapter>();
+
 LoopbackAdapter& LoopbackAdapter::the()
 {
-    static LoopbackAdapter* the;
-    if (!the)
-        the = new LoopbackAdapter;
-    return *the;
+    return *s_loopback;
 }
 
 LoopbackAdapter::LoopbackAdapter()

Kernel/Net/LoopbackAdapter.h

@@ -33,15 +33,13 @@ namespace Kernel {
 class LoopbackAdapter final : public NetworkAdapter {
     AK_MAKE_ETERNAL
 public:
+    LoopbackAdapter();
     static LoopbackAdapter& the();
 
     virtual ~LoopbackAdapter() override;
 
     virtual void send_raw(ReadonlyBytes) override;
     virtual const char* class_name() const override { return "LoopbackAdapter"; }
-
-private:
-    LoopbackAdapter();
 };
 
 }

Kernel/Net/NetworkAdapter.cpp

@@ -33,16 +33,16 @@
 #include <Kernel/Net/LoopbackAdapter.h>
 #include <Kernel/Net/NetworkAdapter.h>
 #include <Kernel/Random.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/StdLib.h>
 
 namespace Kernel {
 
+static auto s_table = make_singleton<Lockable<HashTable<NetworkAdapter*>>>();
+
 static Lockable<HashTable<NetworkAdapter*>>& all_adapters()
 {
-    static Lockable<HashTable<NetworkAdapter*>>* table;
-    if (!table)
-        table = new Lockable<HashTable<NetworkAdapter*>>;
-    return *table;
+    return *s_table;
 }
 
 void NetworkAdapter::for_each(Function<void(NetworkAdapter&)> callback)

Kernel/Net/Routing.cpp

@@ -28,17 +28,17 @@
 #include <Kernel/Net/LoopbackAdapter.h>
 #include <Kernel/Net/Routing.h>
 #include <Kernel/Thread.h>
+#include <Kernel/Singleton.h>
 
 //#define ROUTING_DEBUG
 
 namespace Kernel {
 
+static auto s_arp_table = make_singleton<Lockable<HashMap<IPv4Address, MACAddress>>>();
+
 Lockable<HashMap<IPv4Address, MACAddress>>& arp_table()
 {
-    static Lockable<HashMap<IPv4Address, MACAddress>>* the;
-    if (!the)
-        the = new Lockable<HashMap<IPv4Address, MACAddress>>;
-    return *the;
+    return *s_arp_table;
 }
 
 bool RoutingDecision::is_zero() const

Kernel/Net/TCPSocket.cpp

@@ -33,6 +33,7 @@
 #include <Kernel/Net/TCPSocket.h>
 #include <Kernel/Process.h>
 #include <Kernel/Random.h>
+#include <Kernel/Singleton.h>
 
 //#define TCP_SOCKET_DEBUG
 
@@ -70,11 +71,10 @@ Lockable<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& TCPSocket::closing_socket
     return *s_map;
 }
 
+static auto s_map = make_singleton<Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>>();
+
 Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>& TCPSocket::sockets_by_tuple()
 {
-    static Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>* s_map;
-    if (!s_map)
-        s_map = new Lockable<HashMap<IPv4SocketTuple, TCPSocket*>>;
     return *s_map;
 }
 

Kernel/Net/UDPSocket.cpp

@@ -31,6 +31,7 @@
 #include <Kernel/Net/UDPSocket.h>
 #include <Kernel/Process.h>
 #include <Kernel/Random.h>
+#include <Kernel/Singleton.h>
 
 namespace Kernel {
 
@@ -41,11 +42,10 @@ void UDPSocket::for_each(Function<void(const UDPSocket&)> callback)
         callback(*it.value);
 }
 
+static auto s_map = make_singleton<Lockable<HashMap<u16, UDPSocket*>>>();
+
 Lockable<HashMap<u16, UDPSocket*>>& UDPSocket::sockets_by_port()
 {
-    static Lockable<HashMap<u16, UDPSocket*>>* s_map;
-    if (!s_map)
-        s_map = new Lockable<HashMap<u16, UDPSocket*>>;
     return *s_map;
 }
 

Kernel/Random.cpp

@@ -28,17 +28,15 @@
 #include <Kernel/Arch/i386/CPU.h>
 #include <Kernel/Devices/RandomDevice.h>
 #include <Kernel/Random.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/Time/TimeManagement.h>
 
 namespace Kernel {
 
-static KernelRng* s_the;
+static auto s_the = make_singleton<KernelRng>();
 
 KernelRng& KernelRng::the()
 {
-    if (!s_the) {
-        s_the = new KernelRng;
-    }
     return *s_the;
 }
 

Kernel/Random.h

@@ -127,6 +127,7 @@ class KernelRng : public Lockable<FortunaPRNG<Crypto::Cipher::AESCipher, Crypto:
     AK_MAKE_ETERNAL;
 
 public:
+    KernelRng();
     static KernelRng& the();
 
     void wait_for_entropy();
@@ -134,8 +135,6 @@ public:
     void wake_if_ready();
 
 private:
-    KernelRng();
-
     WaitQueue m_seed_queue;
 };
 

Kernel/SharedBuffer.cpp

@@ -25,16 +25,16 @@
  */
 
 #include <Kernel/Process.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/SharedBuffer.h>
 
 namespace Kernel {
 
+static auto s_map = make_singleton<Lockable<HashMap<int, NonnullOwnPtr<SharedBuffer>>>>();
+
 Lockable<HashMap<int, NonnullOwnPtr<SharedBuffer>>>& shared_buffers()
 {
-    static Lockable<HashMap<int, NonnullOwnPtr<SharedBuffer>>>* map;
-    if (!map)
-        map = new Lockable<HashMap<int, NonnullOwnPtr<SharedBuffer>>>;
-    return *map;
+    return *s_map;
 }
 
 void SharedBuffer::sanity_check(const char* what)

Kernel/TTY/PTYMultiplexer.cpp

@@ -28,6 +28,7 @@
 #include "MasterPTY.h"
 #include <Kernel/FileSystem/FileDescription.h>
 #include <Kernel/Process.h>
+#include <Kernel/Singleton.h>
 #include <LibC/errno_numbers.h>
 
 //#define PTMX_DEBUG
@@ -35,18 +36,16 @@
 namespace Kernel {
 
 static const unsigned s_max_pty_pairs = 8;
-static PTYMultiplexer* s_the;
+static auto s_the = make_singleton<PTYMultiplexer>();
 
 PTYMultiplexer& PTYMultiplexer::the()
 {
-    ASSERT(s_the);
     return *s_the;
 }
 
 PTYMultiplexer::PTYMultiplexer()
     : CharacterDevice(5, 2)
 {
-    s_the = this;
     m_freelist.ensure_capacity(s_max_pty_pairs);
     for (int i = s_max_pty_pairs; i > 0; --i)
         m_freelist.unchecked_append(i - 1);

Kernel/TTY/PTYMultiplexer.h

@@ -40,6 +40,10 @@ public:
     PTYMultiplexer();
     virtual ~PTYMultiplexer() override;
 
+    static void initialize()
+    {
+        the();
+    }
     static PTYMultiplexer& the();
 
     // ^CharacterDevice

Kernel/Time/TimeManagement.cpp

@@ -32,6 +32,7 @@
 #include <Kernel/Time/HardwareTimer.h>
 #include <Kernel/Time/PIT.h>
 #include <Kernel/Time/RTC.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/Time/TimeManagement.h>
 #include <Kernel/VM/MemoryManager.h>
 
@@ -39,12 +40,11 @@
 
 namespace Kernel {
 
-static TimeManagement* s_time_management;
+static auto s_the = make_singleton<TimeManagement>();
 
 TimeManagement& TimeManagement::the()
 {
-    ASSERT(s_time_management);
-    return *s_time_management;
+    return *s_the;
 }
 
 bool TimeManagement::is_system_timer(const HardwareTimer& timer) const
@@ -65,11 +65,9 @@ time_t TimeManagement::epoch_time() const
 
 void TimeManagement::initialize()
 {
-    ASSERT(!s_time_management);
-    if (kernel_command_line().lookup("time").value_or("modern") == "legacy")
-        s_time_management = new TimeManagement(false);
-    else
-        s_time_management = new TimeManagement(true);
+    ASSERT(!s_the.is_initialized());
+    s_the.ensure_instance();
+
 }
 time_t TimeManagement::seconds_since_boot() const
 {
@@ -90,8 +88,9 @@ time_t TimeManagement::boot_time() const
     return RTC::boot_time();
 }
 
-TimeManagement::TimeManagement(bool probe_non_legacy_hardware_timers)
+TimeManagement::TimeManagement()
 {
+    bool probe_non_legacy_hardware_timers = !(kernel_command_line().lookup("time").value_or("modern") == "legacy");
     if (ACPI::is_enabled()) {
         if (!ACPI::Parser::the()->x86_specific_flags().cmos_rtc_not_present) {
             RTC::initialize();
@@ -117,7 +116,8 @@ TimeManagement::TimeManagement(bool probe_non_legacy_hardware_timers)
 
 timeval TimeManagement::now_as_timeval()
 {
-    return { s_time_management->epoch_time(), (suseconds_t)s_time_management->ticks_this_second() * (suseconds_t)1000 };
+    auto* time_management = s_the.ptr();
+    return { time_management->epoch_time(), (suseconds_t)time_management->ticks_this_second() * (suseconds_t)1000 };
 }
 
 Vector<HardwareTimer*> TimeManagement::scan_and_initialize_periodic_timers()

Kernel/Time/TimeManagement.h

@@ -42,6 +42,7 @@ class TimeManagement {
     AK_MAKE_ETERNAL;
 
 public:
+    TimeManagement();
     static bool initialized();
     static void initialize();
     static TimeManagement& the();
@@ -63,7 +64,6 @@ public:
     static timeval now_as_timeval();
 
 private:
-    explicit TimeManagement(bool probe_non_legacy_hardware_timers);
     bool probe_and_set_legacy_hardware_timers();
     bool probe_and_set_non_legacy_hardware_timers();
     Vector<HardwareTimer*> scan_and_initialize_periodic_timers();

Kernel/TimerQueue.cpp

@@ -28,17 +28,16 @@
 #include <AK/NonnullOwnPtr.h>
 #include <AK/OwnPtr.h>
 #include <Kernel/Scheduler.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/Time/TimeManagement.h>
 #include <Kernel/TimerQueue.h>
 
 namespace Kernel {
 
-static TimerQueue* s_the;
+static auto s_the = make_singleton<TimerQueue>();
 
 TimerQueue& TimerQueue::the()
 {
-    if (!s_the)
-        s_the = new TimerQueue;
     return *s_the;
 }
 

Kernel/TimerQueue.h

@@ -56,6 +56,7 @@ struct Timer {
 
 class TimerQueue {
 public:
+    TimerQueue();
     static TimerQueue& the();
 
     TimerId add_timer(NonnullOwnPtr<Timer>&&);
@@ -64,8 +65,6 @@ public:
     void fire();
 
 private:
-    TimerQueue();
-
     void update_next_timer_due();
 
     u64 microseconds_to_ticks(u64 micro_seconds) { return micro_seconds * (m_ticks_per_second / 1'000'000); }

Kernel/VM/MemoryManager.cpp

@@ -39,6 +39,7 @@
 #include <Kernel/VM/PhysicalRegion.h>
 #include <Kernel/VM/PurgeableVMObject.h>
 #include <Kernel/VM/SharedInodeVMObject.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/StdLib.h>
 
 //#define MM_DEBUG
@@ -50,7 +51,7 @@ extern FlatPtr end_of_kernel_bss;
 
 namespace Kernel {
 
-static MemoryManager* s_the;
+static auto s_the = make_singleton<MemoryManager>();
 RecursiveSpinLock s_mm_lock;
 
 MemoryManager& MM
@@ -60,6 +61,8 @@ MemoryManager& MM
 
 MemoryManager::MemoryManager()
 {
+    ASSERT(!s_the.is_initialized());
+
     ScopedSpinLock lock(s_mm_lock);
     m_kernel_page_directory = PageDirectory::create_kernel_page_directory();
     parse_memory_map();
@@ -217,7 +220,7 @@ void MemoryManager::initialize(u32 cpu)
     Processor::current().set_mm_data(*mm_data);
 
     if (cpu == 0)
-        s_the = new MemoryManager;
+        s_the.ensure_instance();
 }
 
 Region* MemoryManager::kernel_region_from_vaddr(VirtualAddress vaddr)

Kernel/VM/MemoryManager.h

@@ -85,6 +85,7 @@ class MemoryManager {
     friend Optional<KBuffer> procfs$memstat(InodeIdentifier);
 
 public:
+    MemoryManager();
     static MemoryManager& the();
 
     static void initialize(u32 cpu);
@@ -160,7 +161,6 @@ public:
     PageDirectory& kernel_page_directory() { return *m_kernel_page_directory; }
 
 private:
-    MemoryManager();
     ~MemoryManager();
 
     enum class AccessSpace { Kernel,

Kernel/VM/PageDirectory.cpp

@@ -27,6 +27,7 @@
 #include <AK/Memory.h>
 #include <Kernel/Process.h>
 #include <Kernel/Random.h>
+#include <Kernel/Singleton.h>
 #include <Kernel/Thread.h>
 #include <Kernel/VM/MemoryManager.h>
 #include <Kernel/VM/PageDirectory.h>
@@ -37,13 +38,12 @@ static const FlatPtr userspace_range_base = 0x00800000;
 static const FlatPtr userspace_range_ceiling = 0xbe000000;
 static const FlatPtr kernelspace_range_base = 0xc0800000;
 
+static auto s_cr3_map = make_singleton<HashMap<u32, PageDirectory*>>();
+
 static HashMap<u32, PageDirectory*>& cr3_map()
 {
     ASSERT_INTERRUPTS_DISABLED();
-    static HashMap<u32, PageDirectory*>* map;
-    if (!map)
-        map = new HashMap<u32, PageDirectory*>;
-    return *map;
+    return *s_cr3_map;
 }
 
 RefPtr<PageDirectory> PageDirectory::find_by_cr3(u32 cr3)

Kernel/init.cpp

@@ -135,10 +135,10 @@ extern "C" [[noreturn]] void init()
     InterruptManagement::initialize();
     ACPI::initialize();
 
-    new VFS;
-    new KeyboardDevice;
-    new PS2MouseDevice;
-    new Console;
+    VFS::initialize();
+    KeyboardDevice::initialize();
+    PS2MouseDevice::create();
+    Console::initialize();
 
     klog() << "Starting SerenityOS...";
 
@@ -146,7 +146,7 @@ extern "C" [[noreturn]] void init()
 
     TimeManagement::initialize();
 
-    new NullDevice;
+    NullDevice::initialize();
     if (!get_serial_debug())
         new SerialDevice(SERIAL_COM1_ADDR, 64);
     new SerialDevice(SERIAL_COM2_ADDR, 65);
@@ -228,7 +228,7 @@ void init_stage2()
         });
 
         if (bxvga_found) {
-            new BXVGADevice;
+            BXVGADevice::initialize();
         } else {
             if (multiboot_info_ptr->framebuffer_type == MULTIBOOT_FRAMEBUFFER_TYPE_RGB || multiboot_info_ptr->framebuffer_type == MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT) {
                 new MBVGADevice(
@@ -237,7 +237,7 @@ void init_stage2()
                     multiboot_info_ptr->framebuffer_width,
                     multiboot_info_ptr->framebuffer_height);
             } else {
-                new BXVGADevice;
+                BXVGADevice::initialize();
             }
         }
     }
@@ -252,9 +252,8 @@ void init_stage2()
     new ZeroDevice;
     new FullDevice;
     new RandomDevice;
-    new PTYMultiplexer;
+    PTYMultiplexer::initialize();
     new SB16;
-    VMWareBackdoor::initialize();
 
     bool force_pio = kernel_command_line().contains("force_pio");