Kernel: Remove kernel processes

Kernel can just use raw threads, pretty muchs the only thing that
process provides is syscalls which kernel threads of course don't
need.

Also this makes init process have pid 1 :D

kernel/kernel/ACPI/ACPI.cpp

@@ -885,7 +885,10 @@ acpi_release_global_lock:
 			set_irq(irq);
 			InterruptController::get().enable_irq(irq);
 
-			Process::create_kernel([](void*) { get().acpi_event_task(); }, nullptr);
+			if (auto thread_or_error = Thread::create_kernel([](void*) { get().acpi_event_task(); }, nullptr); thread_or_error.is_error())
+				dwarnln("Failed to create ACPI thread, power button will not work: {}", thread_or_error.error());
+			else if (auto ret = Processor::scheduler().add_thread(thread_or_error.value()); ret.is_error())
+				dwarnln("Failed to create ACPI thread, power button will not work: {}", ret.error());
 		}
 
 		dprintln("Initialized ACPI interrupts");

kernel/kernel/FS/DevFS/FileSystem.cpp

@@ -45,7 +45,7 @@ namespace Kernel
 
 	void DevFileSystem::initialize_device_updater()
 	{
-		Process::create_kernel(
+		auto* updater_thread = MUST(Thread::create_kernel(
 			[](void* _devfs)
 			{
 				auto* devfs = static_cast<DevFileSystem*>(_devfs);
@@ -59,44 +59,39 @@ namespace Kernel
 					SystemTimer::get().sleep_ms(10);
 				}
 			}, s_instance
-		);
+		));
+		MUST(Processor::scheduler().add_thread(updater_thread));
 
-		auto* sync_process = Process::create_kernel();
-
-		sync_process->add_thread(MUST(Thread::create_kernel(
+		auto* disk_sync_thread = MUST(Thread::create_kernel(
 			[](void* _devfs)
 			{
 				auto* devfs = static_cast<DevFileSystem*>(_devfs);
+
+				constexpr uint64_t sync_interval_ms = 10'000;
+				uint64_t next_sync_ms { sync_interval_ms };
 				while (true)
 				{
 					LockGuard _(devfs->m_device_lock);
 					while (!devfs->m_should_sync)
-						devfs->m_sync_thread_blocker.block_indefinite(&devfs->m_device_lock);
+					{
+						const uint64_t current_ms = SystemTimer::get().ms_since_boot();
+						if (devfs->m_should_sync || current_ms >= next_sync_ms)
+							break;
+						devfs->m_sync_thread_blocker.block_with_timeout_ms(next_sync_ms - current_ms, &devfs->m_device_lock);
+					}
 
 					for (auto& device : devfs->m_devices)
 						if (device->is_storage_device())
 							if (auto ret = static_cast<StorageDevice*>(device.ptr())->sync_disk_cache(); ret.is_error())
 								dwarnln("disk sync: {}", ret.error());
 
+					next_sync_ms = SystemTimer::get().ms_since_boot() + sync_interval_ms;
 					devfs->m_should_sync = false;
 					devfs->m_sync_done.unblock();
 				}
-			}, s_instance, sync_process
-		)));
-
-		sync_process->add_thread(MUST(Kernel::Thread::create_kernel(
-			[](void* _devfs)
-			{
-				auto* devfs = static_cast<DevFileSystem*>(_devfs);
-				while (true)
-				{
-					SystemTimer::get().sleep_ms(10'000);
-					devfs->initiate_sync(false);
-				}
-			}, s_instance, sync_process
-		)));
-
-		sync_process->register_to_scheduler();
+			}, s_instance
+		));
+		MUST(Processor::scheduler().add_thread(disk_sync_thread));
 	}
 
 	void DevFileSystem::initiate_sync(bool should_block)

kernel/kernel/IDT.cpp

@@ -247,7 +247,7 @@ namespace Kernel
 			);
 		}
 
-		if (Thread::current().has_process() && Process::current().is_userspace())
+		if (Thread::current().has_process())
 			process_name = Process::current().name();
 
 #if ARCH(x86_64)

kernel/kernel/Input/PS2/Controller.cpp

@@ -347,7 +347,7 @@ namespace Kernel::Input
 		auto* init_thread = TRY(Thread::create_kernel(
 			[](void* info) {
 				static_cast<PS2DeviceInitInfo*>(info)->controller->device_initialize_task(info);
-			}, &info, nullptr
+			}, &info
 		));
 		TRY(Processor::scheduler().add_thread(init_thread));
 

kernel/kernel/Networking/ARPTable.cpp

@@ -18,14 +18,14 @@ namespace Kernel
 	BAN::ErrorOr<BAN::UniqPtr<ARPTable>> ARPTable::create()
 	{
 		auto arp_table = TRY(BAN::UniqPtr<ARPTable>::create());
-		arp_table->m_process = Process::create_kernel(
+		arp_table->m_thread = TRY(Thread::create_kernel(
 			[](void* arp_table_ptr)
 			{
 				auto& arp_table = *reinterpret_cast<ARPTable*>(arp_table_ptr);
 				arp_table.packet_handle_task();
 			}, arp_table.ptr()
-		);
-		ASSERT(arp_table->m_process);
+		));
+		TRY(Processor::scheduler().add_thread(arp_table->m_thread));
 		return arp_table;
 	}
 
@@ -35,9 +35,9 @@ namespace Kernel
 
 	ARPTable::~ARPTable()
 	{
-		if (m_process)
-			m_process->exit(0, SIGKILL);
-		m_process = nullptr;
+		if (m_thread)
+			m_thread->add_signal(SIGKILL);
+		m_thread = nullptr;
 	}
 
 	BAN::ErrorOr<BAN::MACAddress> ARPTable::get_mac_from_ipv4(NetworkInterface& interface, BAN::IPv4Address ipv4_address)

kernel/kernel/Networking/IPv4Layer.cpp

@@ -21,14 +21,14 @@ namespace Kernel
 	BAN::ErrorOr<BAN::UniqPtr<IPv4Layer>> IPv4Layer::create()
 	{
 		auto ipv4_manager = TRY(BAN::UniqPtr<IPv4Layer>::create());
-		ipv4_manager->m_process = Process::create_kernel(
+		ipv4_manager->m_thread = TRY(Thread::create_kernel(
 			[](void* ipv4_manager_ptr)
 			{
 				auto& ipv4_manager = *reinterpret_cast<IPv4Layer*>(ipv4_manager_ptr);
 				ipv4_manager.packet_handle_task();
 			}, ipv4_manager.ptr()
-		);
-		ASSERT(ipv4_manager->m_process);
+		));
+		TRY(Processor::scheduler().add_thread(ipv4_manager->m_thread));
 		ipv4_manager->m_pending_packet_buffer = TRY(VirtualRange::create_to_vaddr_range(
 			PageTable::kernel(),
 			KERNEL_OFFSET,
@@ -46,9 +46,9 @@ namespace Kernel
 
 	IPv4Layer::~IPv4Layer()
 	{
-		if (m_process)
-			m_process->exit(0, SIGKILL);
-		m_process = nullptr;
+		if (m_thread)
+			m_thread->add_signal(SIGKILL);
+		m_thread = nullptr;
 	}
 
 	void IPv4Layer::add_ipv4_header(BAN::ByteSpan packet, BAN::IPv4Address src_ipv4, BAN::IPv4Address dst_ipv4, uint8_t protocol) const

kernel/kernel/Networking/TCPSocket.cpp

@@ -1,6 +1,7 @@
 #include <kernel/Lock/LockGuard.h>
 #include <kernel/Networking/NetworkManager.h>
 #include <kernel/Networking/TCPSocket.h>
+#include <kernel/Process.h>
 #include <kernel/Random.h>
 #include <kernel/Timer/Timer.h>
 
@@ -42,12 +43,13 @@ namespace Kernel
 			PageTable::Flags::ReadWrite | PageTable::Flags::Present,
 			true
 		));
-		socket->m_process = Process::create_kernel(
+		socket->m_thread = TRY(Thread::create_kernel(
 			[](void* socket_ptr)
 			{
 				reinterpret_cast<TCPSocket*>(socket_ptr)->process_task();
 			}, socket.ptr()
-		);
+		));
+		TRY(Processor::scheduler().add_thread(socket->m_thread));
 		// hack to keep socket alive until its process starts
 		socket->ref();
 		return socket;
@@ -63,7 +65,7 @@ namespace Kernel
 	TCPSocket::~TCPSocket()
 	{
 		ASSERT(!is_bound());
-		ASSERT(m_process == nullptr);
+		ASSERT(m_thread == nullptr);
 		dprintln_if(DEBUG_TCP, "Socket destroyed");
 	}
 
@@ -620,7 +622,7 @@ namespace Kernel
 			dprintln_if(DEBUG_TCP, "Socket unbound");
 		}
 
-		m_process = nullptr;
+		m_thread = nullptr;
 	}
 
 	void TCPSocket::remove_listen_child(BAN::RefPtr<TCPSocket> socket)
@@ -652,7 +654,7 @@ namespace Kernel
 
 		LockGuard _(m_mutex);
 
-		while (m_process)
+		while (m_thread)
 		{
 			const uint64_t current_ms = SystemTimer::get().ms_since_boot();
 

kernel/kernel/Networking/UNIX/Socket.cpp

@@ -3,6 +3,7 @@
 #include <kernel/Lock/SpinLockAsMutex.h>
 #include <kernel/Networking/NetworkManager.h>
 #include <kernel/Networking/UNIX/Socket.h>
+#include <kernel/Process.h>
 #include <kernel/Scheduler.h>
 
 #include <fcntl.h>

kernel/kernel/OpenFileDescriptorSet.cpp

@@ -3,6 +3,7 @@
 #include <kernel/Lock/LockGuard.h>
 #include <kernel/Networking/NetworkManager.h>
 #include <kernel/OpenFileDescriptorSet.h>
+#include <kernel/Process.h>
 
 #include <fcntl.h>
 #include <sys/file.h>

kernel/kernel/Process.cpp

@@ -97,21 +97,6 @@ namespace Kernel
 			MUST(Processor::scheduler().add_thread(thread));
 	}
 
-	Process* Process::create_kernel()
-	{
-		auto* process = create_process({ 0, 0, 0, 0 }, 0);
-		return process;
-	}
-
-	Process* Process::create_kernel(entry_t entry, void* data)
-	{
-		auto* process = create_process({ 0, 0, 0, 0 }, 0);
-		auto* thread = MUST(Thread::create_kernel(entry, data, process));
-		process->add_thread(thread);
-		process->register_to_scheduler();
-		return process;
-	}
-
 	BAN::ErrorOr<Process*> Process::create_userspace(const Credentials& credentials, BAN::StringView path, BAN::Span<BAN::StringView> arguments)
 	{
 		auto* process = create_process(credentials, 0);
@@ -609,7 +594,6 @@ namespace Kernel
 		forked->m_page_table = BAN::move(page_table);
 		forked->m_open_file_descriptors = BAN::move(*open_file_descriptors);
 		forked->m_mapped_regions = BAN::move(mapped_regions);
-		forked->m_is_userspace = m_is_userspace;
 		forked->m_has_called_exec = false;
 		memcpy(forked->m_signal_handlers, m_signal_handlers, sizeof(m_signal_handlers));
 

kernel/kernel/Scheduler.cpp

@@ -119,7 +119,7 @@ namespace Kernel
 
 	BAN::ErrorOr<void> Scheduler::initialize()
 	{
-		m_idle_thread = TRY(Thread::create_kernel([](void*) { asm volatile("1: hlt; jmp 1b"); }, nullptr, nullptr));
+		m_idle_thread = TRY(Thread::create_kernel([](void*) { asm volatile("1: hlt; jmp 1b"); }, nullptr));
 		ASSERT(m_idle_thread);
 
 		size_t processor_index = 0;

kernel/kernel/Terminal/TTY.cpp

@@ -161,7 +161,7 @@ namespace Kernel
 		static bool initialized = false;
 		ASSERT(!initialized);
 
-		auto* thread = MUST(Thread::create_kernel(&TTY::keyboard_task, nullptr, nullptr));
+		auto* thread = MUST(Thread::create_kernel(&TTY::keyboard_task, nullptr));
 		MUST(Processor::scheduler().add_thread(thread));
 
 		DevFileSystem::get().add_inode("tty", MUST(DevTTY::create(0666, 0, 0)));

kernel/kernel/Thread.cpp

@@ -69,10 +69,10 @@ namespace Kernel
 		s_default_sse_storage_initialized = true;
 	}
 
-	BAN::ErrorOr<Thread*> Thread::create_kernel(entry_t entry, void* data, Process* process)
+	BAN::ErrorOr<Thread*> Thread::create_kernel(entry_t entry, void* data)
 	{
 		// Create the thread object
-		Thread* thread = new Thread(s_next_tid++, process);
+		Thread* thread = new Thread(s_next_tid++, nullptr);
 		if (thread == nullptr)
 			return BAN::Error::from_errno(ENOMEM);
 		BAN::ScopeGuard thread_deleter([thread] { delete thread; });

kernel/kernel/USB/Hub/HubDriver.cpp

@@ -215,9 +215,8 @@ namespace Kernel
 			m_changed_ports |= 1u << port_id;
 		}
 
-		m_port_updater = Process::create_kernel([](void* data) { reinterpret_cast<USBHubDriver*>(data)->port_updater_task(); }, this);
-		if (m_port_updater == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
+		m_port_updater = TRY(Thread::create_kernel([](void* data) { reinterpret_cast<USBHubDriver*>(data)->port_updater_task(); }, this));
+		TRY(Processor::scheduler().add_thread(m_port_updater));
 
 		return {};
 	}

kernel/kernel/USB/XHCI/Controller.cpp

@@ -135,9 +135,8 @@ namespace Kernel
 		while (operational.usbsts & XHCI::USBSTS::HCHalted)
 			continue;
 
-		m_port_updater = Process::create_kernel([](void* data) { reinterpret_cast<XHCIController*>(data)->port_updater_task(); }, this);
-		if (m_port_updater == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
+		m_port_updater = TRY(Thread::create_kernel([](void* data) { reinterpret_cast<XHCIController*>(data)->port_updater_task(); }, this));
+		TRY(Processor::scheduler().add_thread(m_port_updater));
 
 		return {};
 	}

kernel/kernel/kernel.cpp

@@ -199,7 +199,8 @@ extern "C" void kernel_main(uint32_t boot_magic, uint32_t boot_info)
 	Processor::wait_until_processors_ready();
 	MUST(Processor::scheduler().initialize());
 
-	Process::create_kernel(init2, nullptr);
+	auto* init_thread = MUST(Thread::create_kernel(init2, nullptr));
+	MUST(Processor::scheduler().add_thread(init_thread));
 	Processor::yield();
 
 	ASSERT_NOT_REACHED();