diff --git a/AK/OwnPtr.h b/AK/OwnPtr.h
index 582693d9e41..b950076efc0 100644
--- a/AK/OwnPtr.h
+++ b/AK/OwnPtr.h
@@ -6,13 +6,9 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/NonnullOwnPtr.h>
 #include <AK/RefCounted.h>
-#ifdef KERNEL
-#    include <Kernel/API/KResult.h>
-#else
-#    include <AK/Error.h>
-#endif
 
 #define OWNPTR_SCRUB_BYTE 0xf0
 
@@ -209,16 +205,6 @@ inline OwnPtr<T> adopt_own_if_nonnull(T* object)
     return {};
 }
 
-#ifdef KERNEL
-template<typename T>
-inline Kernel::KResultOr<NonnullOwnPtr<T>> adopt_nonnull_own_or_enomem(T* object)
-{
-    auto result = adopt_own_if_nonnull(object);
-    if (!result)
-        return ENOMEM;
-    return result.release_nonnull();
-}
-#else
 template<typename T>
 inline ErrorOr<NonnullOwnPtr<T>> adopt_nonnull_own_or_enomem(T* object)
 {
@@ -227,7 +213,6 @@ inline ErrorOr<NonnullOwnPtr<T>> adopt_nonnull_own_or_enomem(T* object)
         return ENOMEM;
     return result.release_nonnull();
 }
-#endif
 
 template<typename T, class... Args>
 requires(IsConstructible<T, Args...>) inline OwnPtr<T> try_make(Args&&... args)
diff --git a/AK/Try.h b/AK/Try.h
index 4efb21a5a0f..15d470e86b9 100644
--- a/AK/Try.h
+++ b/AK/Try.h
@@ -7,7 +7,7 @@
 #pragma once
 
 // NOTE: This macro works with any result type that has the expected APIs.
-//       It's designed with AK::Result and Kernel::KResult in mind.
+//       It's designed with AK::Result and AK::Error in mind.
 
 #define TRY(expression)                               \
     ({                                                \
diff --git a/Kernel/API/KResult.h b/Kernel/API/KResult.h
deleted file mode 100644
index aa5334f76f3..00000000000
--- a/Kernel/API/KResult.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <AK/Assertions.h>
-#include <AK/Format.h>
-#include <AK/Platform.h>
-#include <AK/StdLibExtras.h>
-#include <AK/Try.h>
-#include <LibC/errno_numbers.h>
-
-namespace Kernel {
-
-enum KSuccessTag {
-    KSuccess
-};
-
-class [[nodiscard]] KResult {
-public:
-    KResult(ErrnoCode error)
-        : m_error(-error)
-    {
-    }
-    KResult(KSuccessTag)
-        : m_error(0)
-    {
-    }
-    [[nodiscard]] int error() const { return m_error; }
-
-    [[nodiscard]] bool is_success() const { return m_error == 0; }
-    [[nodiscard]] bool is_error() const { return !is_success(); }
-
-    bool operator==(ErrnoCode error) const { return is_error() && m_error == -error; }
-    bool operator!=(ErrnoCode error) const { return !is_error() || m_error != -error; }
-
-    bool operator!=(KSuccessTag) const { return is_error(); }
-    bool operator==(KSuccessTag) const { return !is_error(); }
-
-    // NOTE: These are here to make KResult usable with TRY()
-    KResult release_error() { return *this; }
-    void release_value() { }
-
-private:
-    template<typename T>
-    friend class KResultOr;
-    KResult() = default;
-
-    int m_error { 0 };
-};
-
-template<typename T>
-class [[nodiscard]] KResultOr {
-public:
-    KResultOr(KResult error)
-        : m_error(error)
-        , m_is_error(true)
-    {
-    }
-
-    KResultOr(ErrnoCode error)
-        : m_error(error)
-        , m_is_error(true)
-    {
-    }
-
-    ALWAYS_INLINE KResultOr(T&& value)
-        : m_have_storage(true)
-    {
-        new (&m_storage) T(move(value));
-    }
-
-    ALWAYS_INLINE KResultOr(const T& value)
-        : m_have_storage(true)
-    {
-        new (&m_storage) T(value);
-    }
-
-    template<typename U>
-    ALWAYS_INLINE KResultOr(U&& value) requires(!IsSame<RemoveCVReference<U>, KResultOr<T>>)
-        : m_have_storage(true)
-    {
-        new (&m_storage) T(forward<U>(value));
-    }
-
-    KResultOr(KResultOr&& other)
-    {
-        m_is_error = other.m_is_error;
-        if (m_is_error) {
-            m_error = other.m_error;
-        } else {
-            if (other.m_have_storage) {
-                new (&m_storage) T(move(other.value()));
-                m_have_storage = true;
-                other.value().~T();
-                other.m_have_storage = false;
-            }
-        }
-        other.m_is_error = true;
-        other.m_error = KSuccess;
-    }
-
-    KResultOr& operator=(KResultOr&& other)
-    {
-        if (&other == this)
-            return *this;
-        if (!m_is_error && m_have_storage) {
-            value().~T();
-            m_have_storage = false;
-        }
-        m_is_error = other.m_is_error;
-        if (m_is_error) {
-            m_error = other.m_error;
-        } else {
-            if (other.m_have_storage) {
-                new (&m_storage) T(move(other.value()));
-                m_have_storage = true;
-                other.value().~T();
-                other.m_have_storage = false;
-            }
-        }
-        other.m_is_error = true;
-        other.m_error = KSuccess;
-        return *this;
-    }
-
-    ~KResultOr()
-    {
-        if (!m_is_error && m_have_storage)
-            value().~T();
-    }
-
-    [[nodiscard]] bool is_error() const { return m_is_error; }
-
-    [[nodiscard]] ALWAYS_INLINE KResult error() const
-    {
-        VERIFY(m_is_error);
-        return m_error;
-    }
-
-    KResult result() const { return m_is_error ? m_error : KSuccess; }
-
-    [[nodiscard]] ALWAYS_INLINE T& value() &
-    {
-        VERIFY(!m_is_error);
-        return *reinterpret_cast<T*>(&m_storage);
-    }
-
-    [[nodiscard]] ALWAYS_INLINE T const& value() const&
-    {
-        VERIFY(!m_is_error);
-        return *reinterpret_cast<T*>(&m_storage);
-    }
-
-    T value() && = delete;
-
-    [[nodiscard]] ALWAYS_INLINE T release_value()
-    {
-        VERIFY(!m_is_error);
-        VERIFY(m_have_storage);
-        T released_value(move(*reinterpret_cast<T*>(&m_storage)));
-        value().~T();
-        m_have_storage = false;
-        return released_value;
-    }
-
-    KResult release_error()
-    {
-        VERIFY(m_is_error);
-        return m_error;
-    }
-
-private:
-    union {
-        alignas(T) char m_storage[sizeof(T)];
-        KResult m_error;
-    };
-    bool m_is_error { false };
-    bool m_have_storage { false };
-};
-
-}
-
-using Kernel::KResult;
-using Kernel::KResultOr;
-using Kernel::KSuccess;
-
-template<>
-struct AK::Formatter<KResult> : Formatter<FormatString> {
-    void format(FormatBuilder& builder, Kernel::KResult value)
-    {
-        if (value.is_error())
-            return AK::Formatter<FormatString>::format(builder, "KResult({})", value.error());
-        return AK::Formatter<FormatString>::format(builder, "KResult(success)");
-    }
-};
diff --git a/Kernel/Arch/aarch64/dummy.cpp b/Kernel/Arch/aarch64/dummy.cpp
index d0d6d4ade5e..3ac7310e319 100644
--- a/Kernel/Arch/aarch64/dummy.cpp
+++ b/Kernel/Arch/aarch64/dummy.cpp
@@ -44,7 +44,7 @@ namespace Kernel {
 void dump_backtrace(PrintToScreen) { }
 
 // KString.cpp
-KResultOr<NonnullOwnPtr<KString>> KString::try_create_uninitialized(size_t, char*&) { return ENOMEM; }
+ErrorOr<NonnullOwnPtr<KString>> KString::try_create_uninitialized(size_t, char*&) { return ENOMEM; }
 void KString::operator delete(void*) { }
 
 // SafeMem.h
diff --git a/Kernel/Bus/PCI/Access.cpp b/Kernel/Bus/PCI/Access.cpp
index ad1f8c9106d..664d7bc1502 100644
--- a/Kernel/Bus/PCI/Access.cpp
+++ b/Kernel/Bus/PCI/Access.cpp
@@ -5,8 +5,8 @@
  */
 
 #include <AK/ByteReader.h>
+#include <AK/Error.h>
 #include <AK/HashTable.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Arch/x86/IO.h>
 #include <Kernel/Bus/PCI/Access.h>
 #include <Kernel/Debug.h>
diff --git a/Kernel/Bus/PCI/SysFSPCI.cpp b/Kernel/Bus/PCI/SysFSPCI.cpp
index a8fc6e9ddc8..ab79bdd4f6f 100644
--- a/Kernel/Bus/PCI/SysFSPCI.cpp
+++ b/Kernel/Bus/PCI/SysFSPCI.cpp
@@ -59,19 +59,19 @@ PCIDeviceAttributeSysFSComponent::PCIDeviceAttributeSysFSComponent(String name,
 {
 }
 
-KResultOr<size_t> PCIDeviceAttributeSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> PCIDeviceAttributeSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     auto blob = TRY(try_to_generate_buffer());
 
     if ((size_t)offset >= blob->size())
-        return KSuccess;
+        return 0;
 
     ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
     TRY(buffer.write(blob->data() + offset, nread));
     return nread;
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> PCIDeviceAttributeSysFSComponent::try_to_generate_buffer() const
+ErrorOr<NonnullOwnPtr<KBuffer>> PCIDeviceAttributeSysFSComponent::try_to_generate_buffer() const
 {
     String value;
     switch (m_field_bytes_width) {
diff --git a/Kernel/Bus/PCI/SysFSPCI.h b/Kernel/Bus/PCI/SysFSPCI.h
index 4286150eafb..60b2bfddabc 100644
--- a/Kernel/Bus/PCI/SysFSPCI.h
+++ b/Kernel/Bus/PCI/SysFSPCI.h
@@ -37,11 +37,11 @@ class PCIDeviceAttributeSysFSComponent : public SysFSComponent {
 public:
     static NonnullRefPtr<PCIDeviceAttributeSysFSComponent> create(String name, const PCIDeviceSysFSDirectory& device, PCI::RegisterOffset offset, size_t field_bytes_width);
 
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
     virtual ~PCIDeviceAttributeSysFSComponent() {};
 
 protected:
-    KResultOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const;
+    ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const;
     PCIDeviceAttributeSysFSComponent(String name, const PCIDeviceSysFSDirectory& device, PCI::RegisterOffset offset, size_t field_bytes_width);
     NonnullRefPtr<PCIDeviceSysFSDirectory> m_device;
     PCI::RegisterOffset m_offset;
diff --git a/Kernel/Bus/USB/SysFSUSB.cpp b/Kernel/Bus/USB/SysFSUSB.cpp
index 5bc16aa245d..d242c8cb851 100644
--- a/Kernel/Bus/USB/SysFSUSB.cpp
+++ b/Kernel/Bus/USB/SysFSUSB.cpp
@@ -23,7 +23,7 @@ SysFSUSBDeviceInformation::~SysFSUSBDeviceInformation()
 {
 }
 
-KResult SysFSUSBDeviceInformation::try_generate(KBufferBuilder& builder)
+ErrorOr<void> SysFSUSBDeviceInformation::try_generate(KBufferBuilder& builder)
 {
     VERIFY(m_lock.is_locked());
     JsonArraySerializer array { builder };
@@ -44,10 +44,10 @@ KResult SysFSUSBDeviceInformation::try_generate(KBufferBuilder& builder)
     obj.add("num_configurations", m_device->device_descriptor().num_configurations);
     obj.finish();
     array.finish();
-    return KSuccess;
+    return {};
 }
 
-KResult SysFSUSBDeviceInformation::refresh_data(OpenFileDescription& description) const
+ErrorOr<void> SysFSUSBDeviceInformation::refresh_data(OpenFileDescription& description) const
 {
     MutexLocker lock(m_lock);
     auto& cached_data = description.data();
@@ -60,10 +60,10 @@ KResult SysFSUSBDeviceInformation::refresh_data(OpenFileDescription& description
     typed_cached_data.buffer = builder.build();
     if (!typed_cached_data.buffer)
         return ENOMEM;
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
+ErrorOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     dbgln_if(PROCFS_DEBUG, "SysFSUSBDeviceInformation @ {}: read_bytes offset: {} count: {}", name(), offset, count);
 
@@ -71,13 +71,13 @@ KResultOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t cou
     VERIFY(buffer.user_or_kernel_ptr());
 
     if (!description)
-        return KResult(EIO);
+        return Error::from_errno(EIO);
 
     MutexLocker locker(m_lock);
 
     if (!description->data()) {
         dbgln("SysFSUSBDeviceInformation: Do not have cached data!");
-        return KResult(EIO);
+        return Error::from_errno(EIO);
     }
 
     auto& typed_cached_data = static_cast<SysFSInodeData&>(*description->data());
@@ -91,7 +91,7 @@ KResultOr<size_t> SysFSUSBDeviceInformation::read_bytes(off_t offset, size_t cou
     return nread;
 }
 
-KResult SysFSUSBBusDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> SysFSUSBBusDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     SpinlockLocker lock(m_lock);
     // Note: if the parent directory is null, it means something bad happened as this should not happen for the USB directory.
@@ -103,7 +103,7 @@ KResult SysFSUSBBusDirectory::traverse_as_directory(unsigned fsid, Function<bool
         InodeIdentifier identifier = { fsid, device_node.component_index() };
         callback({ device_node.name(), identifier, 0 });
     }
-    return KSuccess;
+    return {};
 }
 
 RefPtr<SysFSComponent> SysFSUSBBusDirectory::lookup(StringView name)
diff --git a/Kernel/Bus/USB/SysFSUSB.h b/Kernel/Bus/USB/SysFSUSB.h
index 2380235647c..9891c87b13a 100644
--- a/Kernel/Bus/USB/SysFSUSB.h
+++ b/Kernel/Bus/USB/SysFSUSB.h
@@ -26,15 +26,15 @@ public:
 protected:
     explicit SysFSUSBDeviceInformation(USB::Device& device);
 
-    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
 
     IntrusiveListNode<SysFSUSBDeviceInformation, RefPtr<SysFSUSBDeviceInformation>> m_list_node;
 
     NonnullRefPtr<USB::Device> m_device;
 
 private:
-    KResult try_generate(KBufferBuilder&);
-    virtual KResult refresh_data(OpenFileDescription& description) const override;
+    ErrorOr<void> try_generate(KBufferBuilder&);
+    virtual ErrorOr<void> refresh_data(OpenFileDescription& description) const override;
     mutable Mutex m_lock { "SysFSUSBDeviceInformation" };
 };
 
@@ -46,7 +46,7 @@ public:
     void plug(USB::Device&);
     void unplug(USB::Device&);
 
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual RefPtr<SysFSComponent> lookup(StringView name) override;
 
 private:
diff --git a/Kernel/Bus/USB/UHCI/UHCIController.cpp b/Kernel/Bus/USB/UHCI/UHCIController.cpp
index b64f4791d0d..88f945408bd 100644
--- a/Kernel/Bus/USB/UHCI/UHCIController.cpp
+++ b/Kernel/Bus/USB/UHCI/UHCIController.cpp
@@ -62,7 +62,7 @@ static constexpr u16 UCHI_PORTSC_NON_WRITE_CLEAR_BIT_MASK = 0x1FF5; // This is u
 static constexpr u8 UHCI_NUMBER_OF_ISOCHRONOUS_TDS = 128;
 static constexpr u16 UHCI_NUMBER_OF_FRAMES = 1024;
 
-KResultOr<NonnullRefPtr<UHCIController>> UHCIController::try_to_initialize(PCI::DeviceIdentifier const& pci_device_identifier)
+ErrorOr<NonnullRefPtr<UHCIController>> UHCIController::try_to_initialize(PCI::DeviceIdentifier const& pci_device_identifier)
 {
     // NOTE: This assumes that address is pointing to a valid UHCI controller.
     auto controller = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) UHCIController(pci_device_identifier)));
@@ -70,7 +70,7 @@ KResultOr<NonnullRefPtr<UHCIController>> UHCIController::try_to_initialize(PCI::
     return controller;
 }
 
-KResult UHCIController::initialize()
+ErrorOr<void> UHCIController::initialize()
 {
     dmesgln("UHCI: Controller found {} @ {}", PCI::get_hardware_id(pci_address()), pci_address());
     dmesgln("UHCI: I/O base {}", m_io_base);
@@ -93,7 +93,7 @@ UNMAP_AFTER_INIT UHCIController::~UHCIController()
 {
 }
 
-KResult UHCIController::reset()
+ErrorOr<void> UHCIController::reset()
 {
     TRY(stop());
 
@@ -126,10 +126,10 @@ KResult UHCIController::reset()
     write_usbintr(0);
     dbgln("UHCI: Reset completed");
 
-    return KSuccess;
+    return {};
 }
 
-UNMAP_AFTER_INIT KResult UHCIController::create_structures()
+UNMAP_AFTER_INIT ErrorOr<void> UHCIController::create_structures()
 {
     m_queue_head_pool = TRY(UHCIDescriptorPool<QueueHead>::try_create("Queue Head Pool"sv));
 
@@ -173,7 +173,7 @@ UNMAP_AFTER_INIT KResult UHCIController::create_structures()
         m_transfer_descriptor_pool->print_pool_information();
     }
 
-    return KSuccess;
+    return {};
 }
 
 UNMAP_AFTER_INIT void UHCIController::setup_schedule()
@@ -245,7 +245,7 @@ TransferDescriptor* UHCIController::allocate_transfer_descriptor()
     return m_transfer_descriptor_pool->try_take_free_descriptor();
 }
 
-KResult UHCIController::stop()
+ErrorOr<void> UHCIController::stop()
 {
     write_usbcmd(read_usbcmd() & ~UHCI_USBCMD_RUN);
     // FIXME: Timeout
@@ -253,10 +253,10 @@ KResult UHCIController::stop()
         if (read_usbsts() & UHCI_USBSTS_HOST_CONTROLLER_HALTED)
             break;
     }
-    return KSuccess;
+    return {};
 }
 
-KResult UHCIController::start()
+ErrorOr<void> UHCIController::start()
 {
     write_usbcmd(read_usbcmd() | UHCI_USBCMD_RUN);
     // FIXME: Timeout
@@ -268,7 +268,7 @@ KResult UHCIController::start()
 
     m_root_hub = TRY(UHCIRootHub::try_create(*this));
     TRY(m_root_hub->setup({}));
-    return KSuccess;
+    return {};
 }
 
 TransferDescriptor* UHCIController::create_transfer_descriptor(Pipe& pipe, PacketID direction, size_t data_len)
@@ -303,7 +303,7 @@ TransferDescriptor* UHCIController::create_transfer_descriptor(Pipe& pipe, Packe
     return td;
 }
 
-KResult UHCIController::create_chain(Pipe& pipe, PacketID direction, Ptr32<u8>& buffer_address, size_t max_size, size_t transfer_size, TransferDescriptor** td_chain, TransferDescriptor** last_td)
+ErrorOr<void> UHCIController::create_chain(Pipe& pipe, PacketID direction, Ptr32<u8>& buffer_address, size_t max_size, size_t transfer_size, TransferDescriptor** td_chain, TransferDescriptor** last_td)
 {
     // We need to create `n` transfer descriptors based on the max
     // size of each transfer (which we've learned from the device already by reading
@@ -345,7 +345,7 @@ KResult UHCIController::create_chain(Pipe& pipe, PacketID direction, Ptr32<u8>&
 
     *last_td = current_td;
     *td_chain = first_td;
-    return KSuccess;
+    return {};
 }
 
 void UHCIController::free_descriptor_chain(TransferDescriptor* first_descriptor)
@@ -361,7 +361,7 @@ void UHCIController::free_descriptor_chain(TransferDescriptor* first_descriptor)
     }
 }
 
-KResultOr<size_t> UHCIController::submit_control_transfer(Transfer& transfer)
+ErrorOr<size_t> UHCIController::submit_control_transfer(Transfer& transfer)
 {
     Pipe& pipe = transfer.pipe(); // Short circuit the pipe related to this transfer
     bool direction_in = (transfer.request().request_type & USB_REQUEST_TRANSFER_DIRECTION_DEVICE_TO_HOST) == USB_REQUEST_TRANSFER_DIRECTION_DEVICE_TO_HOST;
@@ -589,7 +589,7 @@ void UHCIController::reset_port(u8 port)
     m_port_reset_change_statuses |= (1 << port);
 }
 
-KResult UHCIController::set_port_feature(Badge<UHCIRootHub>, u8 port, HubFeatureSelector feature_selector)
+ErrorOr<void> UHCIController::set_port_feature(Badge<UHCIRootHub>, u8 port, HubFeatureSelector feature_selector)
 {
     // The check is done by UHCIRootHub.
     VERIFY(port < NUMBER_OF_ROOT_PORTS);
@@ -621,10 +621,10 @@ KResult UHCIController::set_port_feature(Badge<UHCIRootHub>, u8 port, HubFeature
         return EINVAL;
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResult UHCIController::clear_port_feature(Badge<UHCIRootHub>, u8 port, HubFeatureSelector feature_selector)
+ErrorOr<void> UHCIController::clear_port_feature(Badge<UHCIRootHub>, u8 port, HubFeatureSelector feature_selector)
 {
     // The check is done by UHCIRootHub.
     VERIFY(port < NUMBER_OF_ROOT_PORTS);
@@ -670,7 +670,7 @@ KResult UHCIController::clear_port_feature(Badge<UHCIRootHub>, u8 port, HubFeatu
     else
         write_portsc2(port_data);
 
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/Bus/USB/UHCI/UHCIController.h b/Kernel/Bus/USB/UHCI/UHCIController.h
index d9c426ff3c5..20790479edc 100644
--- a/Kernel/Bus/USB/UHCI/UHCIController.h
+++ b/Kernel/Bus/USB/UHCI/UHCIController.h
@@ -33,24 +33,24 @@ class UHCIController final
 
 public:
     static constexpr u8 NUMBER_OF_ROOT_PORTS = 2;
-    static KResultOr<NonnullRefPtr<UHCIController>> try_to_initialize(PCI::DeviceIdentifier const& pci_device_identifier);
+    static ErrorOr<NonnullRefPtr<UHCIController>> try_to_initialize(PCI::DeviceIdentifier const& pci_device_identifier);
     virtual ~UHCIController() override;
 
     virtual StringView purpose() const override { return "UHCI"sv; }
 
-    virtual KResult initialize() override;
-    virtual KResult reset() override;
-    virtual KResult stop() override;
-    virtual KResult start() override;
+    virtual ErrorOr<void> initialize() override;
+    virtual ErrorOr<void> reset() override;
+    virtual ErrorOr<void> stop() override;
+    virtual ErrorOr<void> start() override;
     void spawn_port_proc();
 
     void do_debug_transfer();
 
-    virtual KResultOr<size_t> submit_control_transfer(Transfer& transfer) override;
+    virtual ErrorOr<size_t> submit_control_transfer(Transfer& transfer) override;
 
     void get_port_status(Badge<UHCIRootHub>, u8, HubStatus&);
-    KResult set_port_feature(Badge<UHCIRootHub>, u8, HubFeatureSelector);
-    KResult clear_port_feature(Badge<UHCIRootHub>, u8, HubFeatureSelector);
+    ErrorOr<void> set_port_feature(Badge<UHCIRootHub>, u8, HubFeatureSelector);
+    ErrorOr<void> clear_port_feature(Badge<UHCIRootHub>, u8, HubFeatureSelector);
 
 private:
     explicit UHCIController(PCI::DeviceIdentifier const& pci_device_identifier);
@@ -75,12 +75,12 @@ private:
 
     virtual bool handle_irq(const RegisterState&) override;
 
-    KResult create_structures();
+    ErrorOr<void> create_structures();
     void setup_schedule();
     size_t poll_transfer_queue(QueueHead& transfer_queue);
 
     TransferDescriptor* create_transfer_descriptor(Pipe& pipe, PacketID direction, size_t data_len);
-    KResult create_chain(Pipe& pipe, PacketID direction, Ptr32<u8>& buffer_address, size_t max_size, size_t transfer_size, TransferDescriptor** td_chain, TransferDescriptor** last_td);
+    ErrorOr<void> create_chain(Pipe& pipe, PacketID direction, Ptr32<u8>& buffer_address, size_t max_size, size_t transfer_size, TransferDescriptor** td_chain, TransferDescriptor** last_td);
     void free_descriptor_chain(TransferDescriptor* first_descriptor);
 
     QueueHead* allocate_queue_head();
diff --git a/Kernel/Bus/USB/UHCI/UHCIDescriptorPool.h b/Kernel/Bus/USB/UHCI/UHCIDescriptorPool.h
index b099e3d1baa..a4658a88c56 100644
--- a/Kernel/Bus/USB/UHCI/UHCIDescriptorPool.h
+++ b/Kernel/Bus/USB/UHCI/UHCIDescriptorPool.h
@@ -28,7 +28,7 @@ class UHCIDescriptorPool {
     static_assert(sizeof(T) <= PAGE_SIZE);
 
 public:
-    static KResultOr<NonnullOwnPtr<UHCIDescriptorPool<T>>> try_create(StringView name)
+    static ErrorOr<NonnullOwnPtr<UHCIDescriptorPool<T>>> try_create(StringView name)
     {
         auto pool_memory_block = TRY(MM.allocate_kernel_region(PAGE_SIZE, "UHCI Descriptor Pool", Memory::Region::Access::ReadWrite));
         return adopt_nonnull_own_or_enomem(new (nothrow) UHCIDescriptorPool(move(pool_memory_block), name));
diff --git a/Kernel/Bus/USB/UHCI/UHCIRootHub.cpp b/Kernel/Bus/USB/UHCI/UHCIRootHub.cpp
index 2f65a492759..936d3edbb03 100644
--- a/Kernel/Bus/USB/UHCI/UHCIRootHub.cpp
+++ b/Kernel/Bus/USB/UHCI/UHCIRootHub.cpp
@@ -83,7 +83,7 @@ static USBHubDescriptor uhci_root_hub_hub_descriptor = {
     0x0,                                  // Self-powered
 };
 
-KResultOr<NonnullOwnPtr<UHCIRootHub>> UHCIRootHub::try_create(NonnullRefPtr<UHCIController> uhci_controller)
+ErrorOr<NonnullOwnPtr<UHCIRootHub>> UHCIRootHub::try_create(NonnullRefPtr<UHCIController> uhci_controller)
 {
     return adopt_nonnull_own_or_enomem(new (nothrow) UHCIRootHub(uhci_controller));
 }
@@ -93,7 +93,7 @@ UHCIRootHub::UHCIRootHub(NonnullRefPtr<UHCIController> uhci_controller)
 {
 }
 
-KResult UHCIRootHub::setup(Badge<UHCIController>)
+ErrorOr<void> UHCIRootHub::setup(Badge<UHCIController>)
 {
     m_hub = TRY(Hub::try_create_root_hub(m_uhci_controller, Device::DeviceSpeed::FullSpeed));
 
@@ -104,10 +104,10 @@ KResult UHCIRootHub::setup(Badge<UHCIController>)
     // NOTE: The root hub is no longer on the default address.
     TRY(m_hub->enumerate_and_power_on_hub());
 
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> UHCIRootHub::handle_control_transfer(Transfer& transfer)
+ErrorOr<size_t> UHCIRootHub::handle_control_transfer(Transfer& transfer)
 {
     auto& request = transfer.request();
     auto* request_data = transfer.buffer().as_ptr() + sizeof(USBRequestData);
diff --git a/Kernel/Bus/USB/UHCI/UHCIRootHub.h b/Kernel/Bus/USB/UHCI/UHCIRootHub.h
index 15972872351..bcfd8ba8504 100644
--- a/Kernel/Bus/USB/UHCI/UHCIRootHub.h
+++ b/Kernel/Bus/USB/UHCI/UHCIRootHub.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/NonnullOwnPtr.h>
 #include <AK/NonnullRefPtr.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Bus/USB/USBHub.h>
 #include <Kernel/Bus/USB/USBTransfer.h>
 
@@ -18,16 +18,16 @@ class UHCIController;
 
 class UHCIRootHub {
 public:
-    static KResultOr<NonnullOwnPtr<UHCIRootHub>> try_create(NonnullRefPtr<UHCIController>);
+    static ErrorOr<NonnullOwnPtr<UHCIRootHub>> try_create(NonnullRefPtr<UHCIController>);
 
     UHCIRootHub(NonnullRefPtr<UHCIController>);
     ~UHCIRootHub() = default;
 
-    KResult setup(Badge<UHCIController>);
+    ErrorOr<void> setup(Badge<UHCIController>);
 
     u8 device_address() const { return m_hub->address(); }
 
-    KResultOr<size_t> handle_control_transfer(Transfer& transfer);
+    ErrorOr<size_t> handle_control_transfer(Transfer& transfer);
 
     void check_for_port_updates() { m_hub->check_for_port_updates(); }
 
diff --git a/Kernel/Bus/USB/USBController.h b/Kernel/Bus/USB/USBController.h
index 3d93bd9e128..f5f8d561f8b 100644
--- a/Kernel/Bus/USB/USBController.h
+++ b/Kernel/Bus/USB/USBController.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/RefCounted.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Bus/USB/USBDevice.h>
 #include <Kernel/Bus/USB/USBTransfer.h>
 
@@ -17,13 +17,13 @@ class USBController : public RefCounted<USBController> {
 public:
     virtual ~USBController() = default;
 
-    virtual KResult initialize() = 0;
+    virtual ErrorOr<void> initialize() = 0;
 
-    virtual KResult reset() = 0;
-    virtual KResult stop() = 0;
-    virtual KResult start() = 0;
+    virtual ErrorOr<void> reset() = 0;
+    virtual ErrorOr<void> stop() = 0;
+    virtual ErrorOr<void> start() = 0;
 
-    virtual KResultOr<size_t> submit_control_transfer(Transfer&) = 0;
+    virtual ErrorOr<size_t> submit_control_transfer(Transfer&) = 0;
 
     u8 allocate_address();
 
diff --git a/Kernel/Bus/USB/USBDevice.cpp b/Kernel/Bus/USB/USBDevice.cpp
index 44228eb84fa..d2de629f45d 100644
--- a/Kernel/Bus/USB/USBDevice.cpp
+++ b/Kernel/Bus/USB/USBDevice.cpp
@@ -16,7 +16,7 @@
 
 namespace Kernel::USB {
 
-KResultOr<NonnullRefPtr<Device>> Device::try_create(USBController const& controller, u8 port, DeviceSpeed speed)
+ErrorOr<NonnullRefPtr<Device>> Device::try_create(USBController const& controller, u8 port, DeviceSpeed speed)
 {
     auto pipe = TRY(Pipe::try_create_pipe(controller, Pipe::Type::Control, Pipe::Direction::Bidirectional, 0, 8, 0));
     auto device = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Device(controller, port, speed, move(pipe))));
@@ -56,7 +56,7 @@ Device::~Device()
 {
 }
 
-KResult Device::enumerate_device()
+ErrorOr<void> Device::enumerate_device()
 {
     USBDeviceDescriptor dev_descriptor {};
 
@@ -118,7 +118,7 @@ KResult Device::enumerate_device()
     dbgln_if(USB_DEBUG, "USB Device: Set address to {}", m_address);
 
     memcpy(&m_device_descriptor, &dev_descriptor, sizeof(USBDeviceDescriptor));
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/Bus/USB/USBDevice.h b/Kernel/Bus/USB/USBDevice.h
index caefbe66c5d..0a255fc0ef2 100644
--- a/Kernel/Bus/USB/USBDevice.h
+++ b/Kernel/Bus/USB/USBDevice.h
@@ -27,13 +27,13 @@ public:
     };
 
 public:
-    static KResultOr<NonnullRefPtr<Device>> try_create(USBController const&, u8, DeviceSpeed);
+    static ErrorOr<NonnullRefPtr<Device>> try_create(USBController const&, u8, DeviceSpeed);
 
     Device(USBController const&, u8, DeviceSpeed, NonnullOwnPtr<Pipe> default_pipe);
     Device(Device const& device, NonnullOwnPtr<Pipe> default_pipe);
     virtual ~Device();
 
-    KResult enumerate_device();
+    ErrorOr<void> enumerate_device();
 
     u8 port() const { return m_device_port; }
     DeviceSpeed speed() const { return m_device_speed; }
diff --git a/Kernel/Bus/USB/USBHub.cpp b/Kernel/Bus/USB/USBHub.cpp
index a486b710b32..f5684858fcb 100644
--- a/Kernel/Bus/USB/USBHub.cpp
+++ b/Kernel/Bus/USB/USBHub.cpp
@@ -14,7 +14,7 @@
 
 namespace Kernel::USB {
 
-KResultOr<NonnullRefPtr<Hub>> Hub::try_create_root_hub(NonnullRefPtr<USBController> controller, DeviceSpeed device_speed)
+ErrorOr<NonnullRefPtr<Hub>> Hub::try_create_root_hub(NonnullRefPtr<USBController> controller, DeviceSpeed device_speed)
 {
     // NOTE: Enumeration does not happen here, as the controller must know what the device address is at all times during enumeration to intercept requests.
     auto pipe = TRY(Pipe::try_create_pipe(controller, Pipe::Type::Control, Pipe::Direction::Bidirectional, 0, 8, 0));
@@ -22,7 +22,7 @@ KResultOr<NonnullRefPtr<Hub>> Hub::try_create_root_hub(NonnullRefPtr<USBControll
     return hub;
 }
 
-KResultOr<NonnullRefPtr<Hub>> Hub::try_create_from_device(Device const& device)
+ErrorOr<NonnullRefPtr<Hub>> Hub::try_create_from_device(Device const& device)
 {
     auto pipe = TRY(Pipe::try_create_pipe(device.controller(), Pipe::Type::Control, Pipe::Direction::Bidirectional, 0, device.device_descriptor().max_packet_size, device.address()));
     auto hub = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Hub(device, move(pipe))));
@@ -40,7 +40,7 @@ Hub::Hub(Device const& device, NonnullOwnPtr<Pipe> default_pipe)
 {
 }
 
-KResult Hub::enumerate_and_power_on_hub()
+ErrorOr<void> Hub::enumerate_and_power_on_hub()
 {
     // USBDevice::enumerate_device must be called before this.
     VERIFY(m_address > 0);
@@ -85,11 +85,11 @@ KResult Hub::enumerate_and_power_on_hub()
 
     memcpy(&m_hub_descriptor, &descriptor, sizeof(USBHubDescriptor));
 
-    return KSuccess;
+    return {};
 }
 
 // USB 2.0 Specification Section 11.24.2.7
-KResult Hub::get_port_status(u8 port, HubStatus& hub_status)
+ErrorOr<void> Hub::get_port_status(u8 port, HubStatus& hub_status)
 {
     // Ports are 1-based.
     if (port == 0 || port > m_hub_descriptor.number_of_downstream_ports)
@@ -103,29 +103,29 @@ KResult Hub::get_port_status(u8 port, HubStatus& hub_status)
         return EIO;
     }
 
-    return KSuccess;
+    return {};
 }
 
 // USB 2.0 Specification Section 11.24.2.2
-KResult Hub::clear_port_feature(u8 port, HubFeatureSelector feature_selector)
+ErrorOr<void> Hub::clear_port_feature(u8 port, HubFeatureSelector feature_selector)
 {
     // Ports are 1-based.
     if (port == 0 || port > m_hub_descriptor.number_of_downstream_ports)
         return EINVAL;
 
     TRY(m_default_pipe->control_transfer(USB_REQUEST_TRANSFER_DIRECTION_HOST_TO_DEVICE | USB_REQUEST_TYPE_CLASS | USB_REQUEST_RECIPIENT_OTHER, HubRequest::CLEAR_FEATURE, feature_selector, port, 0, nullptr));
-    return KSuccess;
+    return {};
 }
 
 // USB 2.0 Specification Section 11.24.2.13
-KResult Hub::set_port_feature(u8 port, HubFeatureSelector feature_selector)
+ErrorOr<void> Hub::set_port_feature(u8 port, HubFeatureSelector feature_selector)
 {
     // Ports are 1-based.
     if (port == 0 || port > m_hub_descriptor.number_of_downstream_ports)
         return EINVAL;
 
     TRY(m_default_pipe->control_transfer(USB_REQUEST_TRANSFER_DIRECTION_HOST_TO_DEVICE | USB_REQUEST_TYPE_CLASS | USB_REQUEST_RECIPIENT_OTHER, HubRequest::SET_FEATURE, feature_selector, port, 0, nullptr));
-    return KSuccess;
+    return {};
 }
 
 void Hub::remove_children_from_sysfs()
@@ -140,16 +140,14 @@ void Hub::check_for_port_updates()
         dbgln_if(USB_DEBUG, "USB Hub: Checking for port updates on port {}...", port_number);
 
         HubStatus port_status {};
-        auto result = get_port_status(port_number, port_status);
-        if (result.is_error()) {
+        if (auto result = get_port_status(port_number, port_status); result.is_error()) {
             dbgln("USB Hub: Error occurred when getting status for port {}: {}. Checking next port instead.", port_number, result.error());
             continue;
         }
 
         if (port_status.change & PORT_STATUS_CONNECT_STATUS_CHANGED) {
             // Clear the connection status change notification.
-            result = clear_port_feature(port_number, HubFeatureSelector::C_PORT_CONNECTION);
-            if (result.is_error()) {
+            if (auto result = clear_port_feature(port_number, HubFeatureSelector::C_PORT_CONNECTION); result.is_error()) {
                 dbgln("USB Hub: Error occurred when clearing port connection change for port {}: {}.", port_number, result.error());
                 return;
             }
@@ -174,8 +172,7 @@ void Hub::check_for_port_updates()
                     IO::delay(debounce_disconnect_check_interval);
                     debounce_timer += debounce_disconnect_check_interval;
 
-                    result = get_port_status(port_number, port_status);
-                    if (result.is_error()) {
+                    if (auto result = get_port_status(port_number, port_status); result.is_error()) {
                         dbgln("USB Hub: Error occurred when getting status while debouncing port {}: {}.", port_number, result.error());
                         return;
                     }
@@ -185,8 +182,8 @@ void Hub::check_for_port_updates()
 
                     dbgln_if(USB_DEBUG, "USB Hub: Connection status changed while debouncing, resetting debounce timer.");
                     debounce_timer = 0;
-                    result = clear_port_feature(port_number, HubFeatureSelector::C_PORT_CONNECTION);
-                    if (result.is_error()) {
+
+                    if (auto result = clear_port_feature(port_number, HubFeatureSelector::C_PORT_CONNECTION); result.is_error()) {
                         dbgln("USB Hub: Error occurred when clearing port connection change while debouncing port {}: {}.", port_number, result.error());
                         return;
                     }
@@ -194,8 +191,7 @@ void Hub::check_for_port_updates()
 
                 // Reset the port
                 dbgln_if(USB_DEBUG, "USB Hub: Debounce finished. Driving reset...");
-                result = set_port_feature(port_number, HubFeatureSelector::PORT_RESET);
-                if (result.is_error()) {
+                if (auto result = set_port_feature(port_number, HubFeatureSelector::PORT_RESET); result.is_error()) {
                     dbgln("USB Hub: Error occurred when resetting port {}: {}.", port_number, result.error());
                     return;
                 }
@@ -207,8 +203,7 @@ void Hub::check_for_port_updates()
                     constexpr u16 reset_delay = 10 * 1000;
                     IO::delay(reset_delay);
 
-                    result = get_port_status(port_number, port_status);
-                    if (result.is_error()) {
+                    if (auto result = get_port_status(port_number, port_status); result.is_error()) {
                         dbgln("USB Hub: Error occurred when getting status while resetting port {}: {}.", port_number, result.error());
                         return;
                     }
@@ -218,8 +213,8 @@ void Hub::check_for_port_updates()
                 }
 
                 // Stop asserting reset. This also causes the port to become enabled.
-                result = clear_port_feature(port_number, HubFeatureSelector::C_PORT_RESET);
-                if (result.is_error()) {
+
+                if (auto result = clear_port_feature(port_number, HubFeatureSelector::C_PORT_RESET); result.is_error()) {
                     dbgln("USB Hub: Error occurred when resetting port {}: {}.", port_number, result.error());
                     return;
                 }
@@ -233,8 +228,7 @@ void Hub::check_for_port_updates()
 
                 // The port is ready to go. This is where we start communicating with the device to set up a driver for it.
 
-                result = get_port_status(port_number, port_status);
-                if (result.is_error()) {
+                if (auto result = get_port_status(port_number, port_status); result.is_error()) {
                     dbgln("USB Hub: Error occurred when getting status for port {} after reset: {}.", port_number, result.error());
                     return;
                 }
diff --git a/Kernel/Bus/USB/USBHub.h b/Kernel/Bus/USB/USBHub.h
index 35529df67ed..0d4da8ee6cf 100644
--- a/Kernel/Bus/USB/USBHub.h
+++ b/Kernel/Bus/USB/USBHub.h
@@ -80,18 +80,18 @@ static constexpr u16 PORT_STATUS_RESET_CHANGED = (1 << 4);
 
 class Hub : public Device {
 public:
-    static KResultOr<NonnullRefPtr<Hub>> try_create_root_hub(NonnullRefPtr<USBController>, DeviceSpeed);
-    static KResultOr<NonnullRefPtr<Hub>> try_create_from_device(Device const&);
+    static ErrorOr<NonnullRefPtr<Hub>> try_create_root_hub(NonnullRefPtr<USBController>, DeviceSpeed);
+    static ErrorOr<NonnullRefPtr<Hub>> try_create_from_device(Device const&);
 
     virtual ~Hub() override = default;
 
-    KResult enumerate_and_power_on_hub();
+    ErrorOr<void> enumerate_and_power_on_hub();
 
-    KResult get_port_status(u8, HubStatus&);
-    KResult clear_port_feature(u8, HubFeatureSelector);
-    KResult set_port_feature(u8, HubFeatureSelector);
+    ErrorOr<void> get_port_status(u8, HubStatus&);
+    ErrorOr<void> clear_port_feature(u8, HubFeatureSelector);
+    ErrorOr<void> set_port_feature(u8, HubFeatureSelector);
 
-    KResult reset_port(u8);
+    ErrorOr<void> reset_port(u8);
 
     void check_for_port_updates();
 
diff --git a/Kernel/Bus/USB/USBPipe.cpp b/Kernel/Bus/USB/USBPipe.cpp
index dd6d358a1cf..940b0f5178b 100644
--- a/Kernel/Bus/USB/USBPipe.cpp
+++ b/Kernel/Bus/USB/USBPipe.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel::USB {
 
-KResultOr<NonnullOwnPtr<Pipe>> Pipe::try_create_pipe(USBController const& controller, Type type, Direction direction, u8 endpoint_address, u16 max_packet_size, i8 device_address, u8 poll_interval)
+ErrorOr<NonnullOwnPtr<Pipe>> Pipe::try_create_pipe(USBController const& controller, Type type, Direction direction, u8 endpoint_address, u16 max_packet_size, i8 device_address, u8 poll_interval)
 {
     return adopt_nonnull_own_or_enomem(new (nothrow) Pipe(controller, type, direction, endpoint_address, max_packet_size, poll_interval, device_address));
 }
@@ -47,7 +47,7 @@ Pipe::Pipe(USBController const& controller, Type type, Direction direction, u8 e
 {
 }
 
-KResultOr<size_t> Pipe::control_transfer(u8 request_type, u8 request, u16 value, u16 index, u16 length, void* data)
+ErrorOr<size_t> Pipe::control_transfer(u8 request_type, u8 request, u16 value, u16 index, u16 length, void* data)
 {
     USBRequestData usb_request;
 
diff --git a/Kernel/Bus/USB/USBPipe.h b/Kernel/Bus/USB/USBPipe.h
index 5a41bdfa9c9..38ff76283ca 100644
--- a/Kernel/Bus/USB/USBPipe.h
+++ b/Kernel/Bus/USB/USBPipe.h
@@ -41,7 +41,7 @@ public:
     };
 
 public:
-    static KResultOr<NonnullOwnPtr<Pipe>> try_create_pipe(USBController const& controller, Type type, Direction direction, u8 endpoint_address, u16 max_packet_size, i8 device_address, u8 poll_interval = 0);
+    static ErrorOr<NonnullOwnPtr<Pipe>> try_create_pipe(USBController const& controller, Type type, Direction direction, u8 endpoint_address, u16 max_packet_size, i8 device_address, u8 poll_interval = 0);
 
     Type type() const { return m_type; }
     Direction direction() const { return m_direction; }
@@ -57,7 +57,7 @@ public:
     void set_toggle(bool toggle) { m_data_toggle = toggle; }
     void set_device_address(i8 addr) { m_device_address = addr; }
 
-    KResultOr<size_t> control_transfer(u8 request_type, u8 request, u16 value, u16 index, u16 length, void* data);
+    ErrorOr<size_t> control_transfer(u8 request_type, u8 request, u16 value, u16 index, u16 length, void* data);
 
     Pipe(USBController const& controller, Type type, Direction direction, u16 max_packet_size);
     Pipe(USBController const& controller, Type type, Direction direction, USBEndpointDescriptor& endpoint);
diff --git a/Kernel/Bus/USB/USBTransfer.cpp b/Kernel/Bus/USB/USBTransfer.cpp
index ca2263b08ee..e2eb744a2b8 100644
--- a/Kernel/Bus/USB/USBTransfer.cpp
+++ b/Kernel/Bus/USB/USBTransfer.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel::USB {
 
-KResultOr<NonnullRefPtr<Transfer>> Transfer::try_create(Pipe& pipe, u16 length)
+ErrorOr<NonnullRefPtr<Transfer>> Transfer::try_create(Pipe& pipe, u16 length)
 {
     // Initialize data buffer for transfer
     // This will definitely need to be refactored in the future, I doubt this will scale well...
diff --git a/Kernel/Bus/USB/USBTransfer.h b/Kernel/Bus/USB/USBTransfer.h
index 35c342feb0f..1c579a79cb6 100644
--- a/Kernel/Bus/USB/USBTransfer.h
+++ b/Kernel/Bus/USB/USBTransfer.h
@@ -19,7 +19,7 @@ namespace Kernel::USB {
 
 class Transfer : public RefCounted<Transfer> {
 public:
-    static KResultOr<NonnullRefPtr<Transfer>> try_create(Pipe&, u16 length);
+    static ErrorOr<NonnullRefPtr<Transfer>> try_create(Pipe&, u16 length);
 
 public:
     Transfer() = delete;
diff --git a/Kernel/Bus/VirtIO/ConsolePort.cpp b/Kernel/Bus/VirtIO/ConsolePort.cpp
index 71210060621..7e3bd0792a2 100644
--- a/Kernel/Bus/VirtIO/ConsolePort.cpp
+++ b/Kernel/Bus/VirtIO/ConsolePort.cpp
@@ -90,7 +90,7 @@ bool ConsolePort::can_read(const OpenFileDescription&, size_t) const
     return m_receive_buffer->used_bytes() > 0;
 }
 
-KResultOr<size_t> ConsolePort::read(OpenFileDescription& desc, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> ConsolePort::read(OpenFileDescription& desc, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (!size)
         return 0;
@@ -100,10 +100,7 @@ KResultOr<size_t> ConsolePort::read(OpenFileDescription& desc, u64, UserOrKernel
     if (!can_read(desc, size))
         return EAGAIN;
 
-    auto bytes_copied_or_error = m_receive_buffer->copy_data_out(size, buffer);
-    if (bytes_copied_or_error.is_error())
-        return bytes_copied_or_error.error();
-    auto bytes_copied = bytes_copied_or_error.release_value();
+    auto bytes_copied = TRY(m_receive_buffer->copy_data_out(size, buffer));
     m_receive_buffer->reclaim_space(m_receive_buffer->start_of_used(), bytes_copied);
 
     if (m_receive_buffer_exhausted && m_receive_buffer->used_bytes() == 0) {
@@ -123,7 +120,7 @@ bool ConsolePort::can_write(const OpenFileDescription&, size_t) const
     return m_console.get_queue(m_transmit_queue).has_free_slots() && m_transmit_buffer->has_space();
 }
 
-KResultOr<size_t> ConsolePort::write(OpenFileDescription& desc, u64, const UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> ConsolePort::write(OpenFileDescription& desc, u64, const UserOrKernelBuffer& data, size_t size)
 {
     if (!size)
         return 0;
@@ -157,7 +154,7 @@ KResultOr<size_t> ConsolePort::write(OpenFileDescription& desc, u64, const UserO
     return total_bytes_copied;
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> ConsolePort::open(int options)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> ConsolePort::open(int options)
 {
     if (!m_open)
         m_console.send_open_control_message(m_port, true);
diff --git a/Kernel/Bus/VirtIO/ConsolePort.h b/Kernel/Bus/VirtIO/ConsolePort.h
index d9b246382d7..81a8aca8741 100644
--- a/Kernel/Bus/VirtIO/ConsolePort.h
+++ b/Kernel/Bus/VirtIO/ConsolePort.h
@@ -38,10 +38,10 @@ private:
     virtual StringView class_name() const override { return "VirtIOConsolePort"sv; }
 
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
 
     static unsigned next_device_id;
     u16 m_receive_queue {};
diff --git a/Kernel/Coredump.cpp b/Kernel/Coredump.cpp
index 4bc2f3a8daa..529d4e3e61b 100644
--- a/Kernel/Coredump.cpp
+++ b/Kernel/Coredump.cpp
@@ -30,7 +30,7 @@ namespace Kernel {
     return region.name().starts_with("LibJS:"sv) || region.name().starts_with("malloc:"sv);
 }
 
-KResultOr<NonnullOwnPtr<Coredump>> Coredump::try_create(NonnullRefPtr<Process> process, StringView output_path)
+ErrorOr<NonnullOwnPtr<Coredump>> Coredump::try_create(NonnullRefPtr<Process> process, StringView output_path)
 {
     if (!process->is_dumpable()) {
         dbgln("Refusing to generate coredump for non-dumpable process {}", process->pid().value());
@@ -56,7 +56,7 @@ Coredump::Coredump(NonnullRefPtr<Process> process, NonnullRefPtr<OpenFileDescrip
     ++m_num_program_headers; // +1 for NOTE segment
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> Coredump::try_create_target_file(Process const& process, StringView output_path)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> Coredump::try_create_target_file(Process const& process, StringView output_path)
 {
     auto output_directory = KLexicalPath::dirname(output_path);
     auto dump_directory = TRY(VirtualFileSystem::the().open_directory(output_directory, VirtualFileSystem::the().root_custody()));
@@ -73,7 +73,7 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> Coredump::try_create_target_file(P
         UidAndGid { process.uid(), process.gid() }));
 }
 
-KResult Coredump::write_elf_header()
+ErrorOr<void> Coredump::write_elf_header()
 {
     ElfW(Ehdr) elf_file_header;
     elf_file_header.e_ident[EI_MAG0] = 0x7f;
@@ -115,10 +115,10 @@ KResult Coredump::write_elf_header()
 
     TRY(m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&elf_file_header)), sizeof(ElfW(Ehdr))));
 
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::write_program_headers(size_t notes_size)
+ErrorOr<void> Coredump::write_program_headers(size_t notes_size)
 {
     size_t offset = sizeof(ElfW(Ehdr)) + m_num_program_headers * sizeof(ElfW(Phdr));
     for (auto& region : m_process->address_space().regions()) {
@@ -162,10 +162,10 @@ KResult Coredump::write_program_headers(size_t notes_size)
 
     TRY(m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&notes_pheader)), sizeof(ElfW(Phdr))));
 
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::write_regions()
+ErrorOr<void> Coredump::write_regions()
 {
     for (auto& region : m_process->address_space().regions()) {
         VERIFY(!region->is_kernel());
@@ -195,16 +195,16 @@ KResult Coredump::write_regions()
             TRY(m_description->write(src_buffer.value(), PAGE_SIZE));
         }
     }
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::write_notes_segment(ReadonlyBytes notes_segment)
+ErrorOr<void> Coredump::write_notes_segment(ReadonlyBytes notes_segment)
 {
     TRY(m_description->write(UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>(notes_segment.data())), notes_segment.size()));
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::create_notes_process_data(auto& builder) const
+ErrorOr<void> Coredump::create_notes_process_data(auto& builder) const
 {
     ELF::Core::ProcessInfo info {};
     info.header.type = ELF::Core::NotesEntryHeader::Type::ProcessInfo;
@@ -230,10 +230,10 @@ KResult Coredump::create_notes_process_data(auto& builder) const
     }
 
     TRY(builder.append('\0'));
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::create_notes_threads_data(auto& builder) const
+ErrorOr<void> Coredump::create_notes_threads_data(auto& builder) const
 {
     for (auto& thread : m_process->threads_for_coredump({})) {
         ELF::Core::ThreadInfo info {};
@@ -245,10 +245,10 @@ KResult Coredump::create_notes_threads_data(auto& builder) const
 
         TRY(builder.append_bytes(ReadonlyBytes { &info, sizeof(info) }));
     }
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::create_notes_regions_data(auto& builder) const
+ErrorOr<void> Coredump::create_notes_regions_data(auto& builder) const
 {
     size_t region_index = 0;
     for (auto& region : m_process->address_space().regions()) {
@@ -274,10 +274,10 @@ KResult Coredump::create_notes_regions_data(auto& builder) const
         else
             TRY(builder.append(name.characters_without_null_termination(), name.length() + 1));
     }
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::create_notes_metadata_data(auto& builder) const
+ErrorOr<void> Coredump::create_notes_metadata_data(auto& builder) const
 {
     ELF::Core::Metadata metadata {};
     metadata.header.type = ELF::Core::NotesEntryHeader::Type::Metadata;
@@ -290,10 +290,10 @@ KResult Coredump::create_notes_metadata_data(auto& builder) const
         });
     }
     TRY(builder.append('\0'));
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::create_notes_segment_data(auto& builder) const
+ErrorOr<void> Coredump::create_notes_segment_data(auto& builder) const
 {
     TRY(create_notes_process_data(builder));
     TRY(create_notes_threads_data(builder));
@@ -304,10 +304,10 @@ KResult Coredump::create_notes_segment_data(auto& builder) const
     null_entry.type = ELF::Core::NotesEntryHeader::Type::Null;
     TRY(builder.append(ReadonlyBytes { &null_entry, sizeof(null_entry) }));
 
-    return KSuccess;
+    return {};
 }
 
-KResult Coredump::write()
+ErrorOr<void> Coredump::write()
 {
     SpinlockLocker lock(m_process->address_space().get_lock());
     ScopedAddressSpaceSwitcher switcher(m_process);
diff --git a/Kernel/Coredump.h b/Kernel/Coredump.h
index 439f02fbdc6..3be53ffe0a0 100644
--- a/Kernel/Coredump.h
+++ b/Kernel/Coredump.h
@@ -15,25 +15,25 @@ namespace Kernel {
 
 class Coredump {
 public:
-    static KResultOr<NonnullOwnPtr<Coredump>> try_create(NonnullRefPtr<Process>, StringView output_path);
+    static ErrorOr<NonnullOwnPtr<Coredump>> try_create(NonnullRefPtr<Process>, StringView output_path);
 
     ~Coredump() = default;
-    KResult write();
+    ErrorOr<void> write();
 
 private:
     Coredump(NonnullRefPtr<Process>, NonnullRefPtr<OpenFileDescription>);
-    static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create_target_file(Process const&, StringView output_path);
+    static ErrorOr<NonnullRefPtr<OpenFileDescription>> try_create_target_file(Process const&, StringView output_path);
 
-    KResult write_elf_header();
-    KResult write_program_headers(size_t notes_size);
-    KResult write_regions();
-    KResult write_notes_segment(ReadonlyBytes);
+    ErrorOr<void> write_elf_header();
+    ErrorOr<void> write_program_headers(size_t notes_size);
+    ErrorOr<void> write_regions();
+    ErrorOr<void> write_notes_segment(ReadonlyBytes);
 
-    KResult create_notes_segment_data(auto&) const;
-    KResult create_notes_process_data(auto&) const;
-    KResult create_notes_threads_data(auto&) const;
-    KResult create_notes_regions_data(auto&) const;
-    KResult create_notes_metadata_data(auto&) const;
+    ErrorOr<void> create_notes_segment_data(auto&) const;
+    ErrorOr<void> create_notes_process_data(auto&) const;
+    ErrorOr<void> create_notes_threads_data(auto&) const;
+    ErrorOr<void> create_notes_regions_data(auto&) const;
+    ErrorOr<void> create_notes_metadata_data(auto&) const;
 
     NonnullRefPtr<Process> m_process;
     NonnullRefPtr<OpenFileDescription> m_description;
diff --git a/Kernel/Devices/AsyncDeviceRequest.h b/Kernel/Devices/AsyncDeviceRequest.h
index 1bd60e571ac..ed690703a53 100644
--- a/Kernel/Devices/AsyncDeviceRequest.h
+++ b/Kernel/Devices/AsyncDeviceRequest.h
@@ -81,7 +81,7 @@ public:
     void* get_private() const { return m_private; }
 
     template<typename... Args>
-    KResult write_to_buffer(UserOrKernelBuffer& buffer, Args... args)
+    ErrorOr<void> write_to_buffer(UserOrKernelBuffer& buffer, Args... args)
     {
         if (in_target_context(buffer))
             return buffer.write(forward<Args>(args)...);
@@ -90,7 +90,7 @@ public:
     }
 
     template<size_t BUFFER_BYTES, typename... Args>
-    KResultOr<size_t> write_to_buffer_buffered(UserOrKernelBuffer& buffer, Args... args)
+    ErrorOr<size_t> write_to_buffer_buffered(UserOrKernelBuffer& buffer, Args... args)
     {
         if (in_target_context(buffer))
             return buffer.write_buffered<BUFFER_BYTES>(forward<Args>(args)...);
@@ -99,7 +99,7 @@ public:
     }
 
     template<typename... Args>
-    KResult read_from_buffer(const UserOrKernelBuffer& buffer, Args... args)
+    ErrorOr<void> read_from_buffer(const UserOrKernelBuffer& buffer, Args... args)
     {
         if (in_target_context(buffer))
             return buffer.read(forward<Args>(args)...);
@@ -108,7 +108,7 @@ public:
     }
 
     template<size_t BUFFER_BYTES, typename... Args>
-    KResultOr<size_t> read_from_buffer_buffered(const UserOrKernelBuffer& buffer, Args... args)
+    ErrorOr<size_t> read_from_buffer_buffered(const UserOrKernelBuffer& buffer, Args... args)
     {
         if (in_target_context(buffer))
             return buffer.read_buffered<BUFFER_BYTES>(forward<Args>(args)...);
diff --git a/Kernel/Devices/ConsoleDevice.cpp b/Kernel/Devices/ConsoleDevice.cpp
index 3fb332747cf..b589d62a95a 100644
--- a/Kernel/Devices/ConsoleDevice.cpp
+++ b/Kernel/Devices/ConsoleDevice.cpp
@@ -37,14 +37,14 @@ bool ConsoleDevice::can_read(const Kernel::OpenFileDescription&, size_t) const
     return false;
 }
 
-Kernel::KResultOr<size_t> ConsoleDevice::read(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t)
+ErrorOr<size_t> ConsoleDevice::read(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t)
 {
     // FIXME: Implement reading from the console.
     //        Maybe we could use a ring buffer for this device?
     return 0;
 }
 
-Kernel::KResultOr<size_t> ConsoleDevice::write(OpenFileDescription&, u64, const Kernel::UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> ConsoleDevice::write(OpenFileDescription&, u64, const Kernel::UserOrKernelBuffer& data, size_t size)
 {
     if (!size)
         return 0;
diff --git a/Kernel/Devices/ConsoleDevice.h b/Kernel/Devices/ConsoleDevice.h
index ec039a972f2..0309e28ff0a 100644
--- a/Kernel/Devices/ConsoleDevice.h
+++ b/Kernel/Devices/ConsoleDevice.h
@@ -24,8 +24,8 @@ public:
     // ^CharacterDevice
     virtual bool can_read(const Kernel::OpenFileDescription&, size_t) const override;
     virtual bool can_write(const Kernel::OpenFileDescription&, size_t) const override { return true; }
-    virtual Kernel::KResultOr<size_t> read(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t) override;
-    virtual Kernel::KResultOr<size_t> write(OpenFileDescription&, u64, const Kernel::UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, Kernel::UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const Kernel::UserOrKernelBuffer&, size_t) override;
     virtual StringView class_name() const override { return "Console"sv; }
 
     void put_char(char);
diff --git a/Kernel/Devices/Device.cpp b/Kernel/Devices/Device.cpp
index 7c9faa960c6..ccd46b18811 100644
--- a/Kernel/Devices/Device.cpp
+++ b/Kernel/Devices/Device.cpp
@@ -44,7 +44,7 @@ SysFSBlockDevicesDirectory::SysFSBlockDevicesDirectory(SysFSDevicesDirectory con
     : SysFSDirectory("block"sv, devices_directory)
 {
 }
-KResult SysFSBlockDevicesDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> SysFSBlockDevicesDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     VERIFY(m_parent_directory);
     callback({ ".", { fsid, component_index() }, 0 });
@@ -57,7 +57,7 @@ KResult SysFSBlockDevicesDirectory::traverse_as_directory(unsigned fsid, Functio
             callback({ exposed_device.name(), { fsid, exposed_device.component_index() }, 0 });
         }
     });
-    return KSuccess;
+    return {};
 }
 RefPtr<SysFSComponent> SysFSBlockDevicesDirectory::lookup(StringView name)
 {
@@ -80,7 +80,7 @@ SysFSCharacterDevicesDirectory::SysFSCharacterDevicesDirectory(SysFSDevicesDirec
     : SysFSDirectory("char"sv, devices_directory)
 {
 }
-KResult SysFSCharacterDevicesDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> SysFSCharacterDevicesDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     VERIFY(m_parent_directory);
     callback({ ".", { fsid, component_index() }, 0 });
@@ -93,7 +93,7 @@ KResult SysFSCharacterDevicesDirectory::traverse_as_directory(unsigned fsid, Fun
             callback({ exposed_device.name(), { fsid, exposed_device.component_index() }, 0 });
         }
     });
-    return KSuccess;
+    return {};
 }
 RefPtr<SysFSComponent> SysFSCharacterDevicesDirectory::lookup(StringView name)
 {
@@ -140,7 +140,7 @@ Device::~Device()
     VERIFY(m_state == State::BeingRemoved);
 }
 
-KResultOr<NonnullOwnPtr<KString>> Device::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> Device::pseudo_path(const OpenFileDescription&) const
 {
     return KString::try_create(String::formatted("device:{},{}", major(), minor()));
 }
diff --git a/Kernel/Devices/Device.h b/Kernel/Devices/Device.h
index 6675242127a..49be585c03a 100644
--- a/Kernel/Devices/Device.h
+++ b/Kernel/Devices/Device.h
@@ -15,10 +15,10 @@
 //   - BlockDevice (random access)
 //   - CharacterDevice (sequential)
 #include <AK/DoublyLinkedList.h>
+#include <AK/Error.h>
 #include <AK/Function.h>
 #include <AK/HashMap.h>
 #include <AK/RefPtr.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Devices/AsyncDeviceRequest.h>
 #include <Kernel/FileSystem/File.h>
 #include <Kernel/FileSystem/SysFS.h>
@@ -40,7 +40,7 @@ public:
     unsigned major() const { return m_major; }
     unsigned minor() const { return m_minor; }
 
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
 
     UserID uid() const { return m_uid; }
     GroupID gid() const { return m_gid; }
@@ -51,7 +51,7 @@ public:
     void process_next_queued_request(Badge<AsyncDeviceRequest>, const AsyncDeviceRequest&);
 
     template<typename AsyncRequestType, typename... Args>
-    KResultOr<NonnullRefPtr<AsyncRequestType>> try_make_request(Args&&... args)
+    ErrorOr<NonnullRefPtr<AsyncRequestType>> try_make_request(Args&&... args)
     {
         auto request = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) AsyncRequestType(*this, forward<Args>(args)...)));
         SpinlockLocker lock(m_requests_lock);
diff --git a/Kernel/Devices/DeviceManagement.h b/Kernel/Devices/DeviceManagement.h
index 50b263ee024..680d72f811f 100644
--- a/Kernel/Devices/DeviceManagement.h
+++ b/Kernel/Devices/DeviceManagement.h
@@ -7,12 +7,12 @@
 #pragma once
 
 #include <AK/Badge.h>
+#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/KResult.h>
 #include <Kernel/API/TimePage.h>
 #include <Kernel/Arch/RegisterState.h>
 #include <Kernel/Devices/ConsoleDevice.h>
@@ -51,7 +51,7 @@ public:
     ConsoleDevice& console_device();
 
     template<typename DeviceType, typename... Args>
-    static inline KResultOr<NonnullRefPtr<DeviceType>> try_create_device(Args&&... args)
+    static inline ErrorOr<NonnullRefPtr<DeviceType>> try_create_device(Args&&... args)
     {
         auto device = TRY(adopt_nonnull_ref_or_enomem(new DeviceType(forward<Args>(args)...)));
         device->after_inserting();
diff --git a/Kernel/Devices/FullDevice.cpp b/Kernel/Devices/FullDevice.cpp
index 48f0288b382..686303d0fdf 100644
--- a/Kernel/Devices/FullDevice.cpp
+++ b/Kernel/Devices/FullDevice.cpp
@@ -34,13 +34,13 @@ bool FullDevice::can_read(const OpenFileDescription&, size_t) const
     return true;
 }
 
-KResultOr<size_t> FullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> FullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     TRY(buffer.memset(0, size));
     return size;
 }
 
-KResultOr<size_t> FullDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
+ErrorOr<size_t> FullDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
 {
     if (size == 0)
         return 0;
diff --git a/Kernel/Devices/FullDevice.h b/Kernel/Devices/FullDevice.h
index fc7e9926ec9..b9ae0432b7c 100644
--- a/Kernel/Devices/FullDevice.h
+++ b/Kernel/Devices/FullDevice.h
@@ -22,8 +22,8 @@ private:
     FullDevice();
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
     virtual StringView class_name() const override { return "FullDevice"sv; }
diff --git a/Kernel/Devices/HID/HIDManagement.h b/Kernel/Devices/HID/HIDManagement.h
index 864cfa71855..667acd7cf1f 100644
--- a/Kernel/Devices/HID/HIDManagement.h
+++ b/Kernel/Devices/HID/HIDManagement.h
@@ -8,11 +8,11 @@
 
 #include <AK/Atomic.h>
 #include <AK/CircularQueue.h>
+#include <AK/Error.h>
 #include <AK/NonnullRefPtrVector.h>
 #include <AK/RefPtr.h>
 #include <AK/Time.h>
 #include <AK/Types.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/API/KeyCode.h>
 #include <Kernel/API/MousePacket.h>
 #include <Kernel/Locking/Spinlock.h>
diff --git a/Kernel/Devices/HID/KeyboardDevice.cpp b/Kernel/Devices/HID/KeyboardDevice.cpp
index fd59ffe8253..ff42ce3e9c8 100644
--- a/Kernel/Devices/HID/KeyboardDevice.cpp
+++ b/Kernel/Devices/HID/KeyboardDevice.cpp
@@ -278,7 +278,7 @@ bool KeyboardDevice::can_read(const OpenFileDescription&, size_t) const
     return !m_queue.is_empty();
 }
 
-KResultOr<size_t> KeyboardDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> KeyboardDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     size_t nread = 0;
     SpinlockLocker lock(m_queue_lock);
@@ -292,13 +292,11 @@ KResultOr<size_t> KeyboardDevice::read(OpenFileDescription&, u64, UserOrKernelBu
 
         lock.unlock();
 
-        auto result = buffer.write_buffered<sizeof(Event)>(sizeof(Event), [&](Bytes bytes) {
+        auto result = TRY(buffer.write_buffered<sizeof(Event)>(sizeof(Event), [&](Bytes bytes) {
             memcpy(bytes.data(), &event, sizeof(Event));
             return bytes.size();
-        });
-        if (result.is_error())
-            return result.error();
-        VERIFY(result.value() == sizeof(Event));
+        }));
+        VERIFY(result == sizeof(Event));
         nread += sizeof(Event);
 
         lock.lock();
@@ -306,7 +304,7 @@ KResultOr<size_t> KeyboardDevice::read(OpenFileDescription&, u64, UserOrKernelBu
     return nread;
 }
 
-KResult KeyboardDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
+ErrorOr<void> KeyboardDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case KEYBOARD_IOCTL_GET_NUM_LOCK: {
@@ -319,7 +317,7 @@ KResult KeyboardDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<
         if (num_lock_value != 0 && num_lock_value != 1)
             return EINVAL;
         m_num_lock_on = !!num_lock_value;
-        return KSuccess;
+        return {};
     }
     case KEYBOARD_IOCTL_GET_CAPS_LOCK: {
         auto output = static_ptr_cast<bool*>(arg);
@@ -330,7 +328,7 @@ KResult KeyboardDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<
         if (caps_lock_value != 0 && caps_lock_value != 1)
             return EINVAL;
         m_caps_lock_on = !!caps_lock_value;
-        return KSuccess;
+        return {};
     }
     default:
         return EINVAL;
diff --git a/Kernel/Devices/HID/KeyboardDevice.h b/Kernel/Devices/HID/KeyboardDevice.h
index 60c10c25fed..f5885aabb40 100644
--- a/Kernel/Devices/HID/KeyboardDevice.h
+++ b/Kernel/Devices/HID/KeyboardDevice.h
@@ -25,16 +25,16 @@ public:
     virtual ~KeyboardDevice() override;
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
     // ^HIDDevice
     virtual Type instrument_type() const override { return Type::Keyboard; }
 
     // ^File
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
 
     void update_modifier(u8 modifier, bool state)
     {
diff --git a/Kernel/Devices/HID/MouseDevice.cpp b/Kernel/Devices/HID/MouseDevice.cpp
index 152ded74212..87441315fa3 100644
--- a/Kernel/Devices/HID/MouseDevice.cpp
+++ b/Kernel/Devices/HID/MouseDevice.cpp
@@ -24,7 +24,7 @@ bool MouseDevice::can_read(const OpenFileDescription&, size_t) const
     return !m_queue.is_empty();
 }
 
-KResultOr<size_t> MouseDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> MouseDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     VERIFY(size > 0);
     size_t nread = 0;
diff --git a/Kernel/Devices/HID/MouseDevice.h b/Kernel/Devices/HID/MouseDevice.h
index 41a939072d8..e240c27cae6 100644
--- a/Kernel/Devices/HID/MouseDevice.h
+++ b/Kernel/Devices/HID/MouseDevice.h
@@ -23,9 +23,9 @@ public:
     virtual ~MouseDevice() override;
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
     // ^HIDDevice
diff --git a/Kernel/Devices/KCOVDevice.cpp b/Kernel/Devices/KCOVDevice.cpp
index 8534e8cbb19..d621472ca3d 100644
--- a/Kernel/Devices/KCOVDevice.cpp
+++ b/Kernel/Devices/KCOVDevice.cpp
@@ -65,7 +65,7 @@ void KCOVDevice::free_process()
     delete kcov_instance;
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> KCOVDevice::open(int options)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> KCOVDevice::open(int options)
 {
     auto pid = Process::current().pid();
     if (proc_instance->get(pid).has_value())
@@ -77,9 +77,8 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> KCOVDevice::open(int options)
     return File::open(options);
 }
 
-KResult KCOVDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
+ErrorOr<void> KCOVDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
-    KResult return_value = KSuccess;
     auto thread = Thread::current();
     auto tid = thread->tid();
     auto pid = thread->pid();
@@ -90,48 +89,34 @@ KResult KCOVDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void
 
     SpinlockLocker locker(kcov_instance->spinlock());
     switch (request) {
-    case KCOV_SETBUFSIZE: {
-        if (kcov_instance->state() >= KCOVInstance::TRACING) {
-            return_value = EBUSY;
-            break;
-        }
-        return_value = kcov_instance->buffer_allocate((FlatPtr)arg.unsafe_userspace_ptr());
-        break;
-    }
-    case KCOV_ENABLE: {
-        if (kcov_instance->state() >= KCOVInstance::TRACING) {
-            return_value = EBUSY;
-            break;
-        }
-        if (!kcov_instance->has_buffer()) {
-            return_value = ENOBUFS;
-            break;
-        }
+    case KCOV_SETBUFSIZE:
+        if (kcov_instance->state() >= KCOVInstance::TRACING)
+            return EBUSY;
+        return kcov_instance->buffer_allocate((FlatPtr)arg.unsafe_userspace_ptr());
+    case KCOV_ENABLE:
+        if (kcov_instance->state() >= KCOVInstance::TRACING)
+            return EBUSY;
+        if (!kcov_instance->has_buffer())
+            return ENOBUFS;
         VERIFY(kcov_instance->state() == KCOVInstance::OPENED);
         kcov_instance->set_state(KCOVInstance::TRACING);
         thread_instance->set(tid, kcov_instance);
-        break;
-    }
+        return {};
     case KCOV_DISABLE: {
         auto maybe_kcov_instance = thread_instance->get(tid);
-        if (!maybe_kcov_instance.has_value()) {
-            return_value = ENOENT;
-            break;
-        }
+        if (!maybe_kcov_instance.has_value())
+            return ENOENT;
         VERIFY(kcov_instance->state() == KCOVInstance::TRACING);
         kcov_instance->set_state(KCOVInstance::OPENED);
         thread_instance->remove(tid);
-        break;
+        return {};
     }
-    default: {
-        return_value = EINVAL;
+    default:
+        return EINVAL;
     }
-    };
-
-    return return_value;
 }
 
-KResultOr<Memory::Region*> KCOVDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+ErrorOr<Memory::Region*> KCOVDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     auto pid = process.pid();
     auto maybe_kcov_instance = proc_instance->get(pid);
diff --git a/Kernel/Devices/KCOVDevice.h b/Kernel/Devices/KCOVDevice.h
index 7905e4002da..3535752c717 100644
--- a/Kernel/Devices/KCOVDevice.h
+++ b/Kernel/Devices/KCOVDevice.h
@@ -23,8 +23,8 @@ public:
     static void free_process();
 
     // ^File
-    KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
-    KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
+    ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    ErrorOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
 
 protected:
     KCOVDevice();
@@ -34,9 +34,9 @@ protected:
     virtual bool can_read(const OpenFileDescription&, size_t) const override final { return true; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override final { return true; }
     virtual void start_request(AsyncBlockDeviceRequest& request) override final { request.complete(AsyncDeviceRequest::Failure); }
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
 };
 
 }
diff --git a/Kernel/Devices/KCOVInstance.cpp b/Kernel/Devices/KCOVInstance.cpp
index 39441bca299..9286675ee79 100644
--- a/Kernel/Devices/KCOVInstance.cpp
+++ b/Kernel/Devices/KCOVInstance.cpp
@@ -14,7 +14,7 @@ KCOVInstance::KCOVInstance(ProcessID pid)
     m_pid = pid;
 }
 
-KResult KCOVInstance::buffer_allocate(size_t buffer_size_in_entries)
+ErrorOr<void> KCOVInstance::buffer_allocate(size_t buffer_size_in_entries)
 {
     if (buffer_size_in_entries < 2 || buffer_size_in_entries > KCOV_MAX_ENTRIES)
         return EINVAL;
@@ -34,7 +34,7 @@ KResult KCOVInstance::buffer_allocate(size_t buffer_size_in_entries)
         Memory::Region::Access::ReadWrite));
 
     m_buffer = (u64*)m_kernel_region->vaddr().as_ptr();
-    return KSuccess;
+    return {};
 }
 
 void KCOVInstance::buffer_add_pc(u64 pc)
diff --git a/Kernel/Devices/KCOVInstance.h b/Kernel/Devices/KCOVInstance.h
index b9099ff6010..097e7b64681 100644
--- a/Kernel/Devices/KCOVInstance.h
+++ b/Kernel/Devices/KCOVInstance.h
@@ -31,7 +31,7 @@ class KCOVInstance final {
 public:
     explicit KCOVInstance(ProcessID pid);
 
-    KResult buffer_allocate(size_t buffer_size_in_entries);
+    ErrorOr<void> buffer_allocate(size_t buffer_size_in_entries);
     bool has_buffer() const { return m_buffer != nullptr; }
     void buffer_add_pc(u64 pc);
 
diff --git a/Kernel/Devices/MemoryDevice.cpp b/Kernel/Devices/MemoryDevice.cpp
index 3a0d42ad7ee..c728ccb1856 100644
--- a/Kernel/Devices/MemoryDevice.cpp
+++ b/Kernel/Devices/MemoryDevice.cpp
@@ -31,7 +31,7 @@ UNMAP_AFTER_INIT MemoryDevice::~MemoryDevice()
 {
 }
 
-KResultOr<size_t> MemoryDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
+ErrorOr<size_t> MemoryDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
 {
     TODO();
 }
@@ -41,7 +41,7 @@ void MemoryDevice::did_seek(OpenFileDescription&, off_t)
     TODO();
 }
 
-KResultOr<Memory::Region*> MemoryDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+ErrorOr<Memory::Region*> MemoryDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     auto viewed_address = PhysicalAddress(offset);
 
diff --git a/Kernel/Devices/MemoryDevice.h b/Kernel/Devices/MemoryDevice.h
index 363a09bd829..90c3d928d72 100644
--- a/Kernel/Devices/MemoryDevice.h
+++ b/Kernel/Devices/MemoryDevice.h
@@ -21,7 +21,7 @@ public:
     static NonnullRefPtr<MemoryDevice> must_create();
     ~MemoryDevice();
 
-    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
 
 private:
     MemoryDevice();
@@ -30,8 +30,8 @@ private:
     virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return false; }
     virtual bool is_seekable() const override { return true; }
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
 
     virtual void did_seek(OpenFileDescription&, off_t) override;
 
diff --git a/Kernel/Devices/NullDevice.cpp b/Kernel/Devices/NullDevice.cpp
index 29d27f69225..efd78ca75aa 100644
--- a/Kernel/Devices/NullDevice.cpp
+++ b/Kernel/Devices/NullDevice.cpp
@@ -33,12 +33,12 @@ bool NullDevice::can_read(const OpenFileDescription&, size_t) const
     return true;
 }
 
-KResultOr<size_t> NullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
+ErrorOr<size_t> NullDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
 {
     return 0;
 }
 
-KResultOr<size_t> NullDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t buffer_size)
+ErrorOr<size_t> NullDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t buffer_size)
 {
     return buffer_size;
 }
diff --git a/Kernel/Devices/NullDevice.h b/Kernel/Devices/NullDevice.h
index bc638ab4a36..e95c0cd51f7 100644
--- a/Kernel/Devices/NullDevice.h
+++ b/Kernel/Devices/NullDevice.h
@@ -22,8 +22,8 @@ public:
 private:
     NullDevice();
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual StringView class_name() const override { return "NullDevice"sv; }
diff --git a/Kernel/Devices/RandomDevice.cpp b/Kernel/Devices/RandomDevice.cpp
index cc669783664..5c8790c98fc 100644
--- a/Kernel/Devices/RandomDevice.cpp
+++ b/Kernel/Devices/RandomDevice.cpp
@@ -33,7 +33,7 @@ bool RandomDevice::can_read(const OpenFileDescription&, size_t) const
     return true;
 }
 
-KResultOr<size_t> RandomDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> RandomDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     return buffer.write_buffered<256>(size, [&](Bytes bytes) {
         get_good_random_bytes(bytes);
@@ -41,7 +41,7 @@ KResultOr<size_t> RandomDevice::read(OpenFileDescription&, u64, UserOrKernelBuff
     });
 }
 
-KResultOr<size_t> RandomDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
+ErrorOr<size_t> RandomDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
 {
     // FIXME: Use input for entropy? I guess that could be a neat feature?
     return size;
diff --git a/Kernel/Devices/RandomDevice.h b/Kernel/Devices/RandomDevice.h
index bdb804826b4..cd1ebc08f83 100644
--- a/Kernel/Devices/RandomDevice.h
+++ b/Kernel/Devices/RandomDevice.h
@@ -22,8 +22,8 @@ private:
     RandomDevice();
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
     virtual StringView class_name() const override { return "RandomDevice"sv; }
diff --git a/Kernel/Devices/SB16.cpp b/Kernel/Devices/SB16.cpp
index 229b8b1d030..027bde6595a 100644
--- a/Kernel/Devices/SB16.cpp
+++ b/Kernel/Devices/SB16.cpp
@@ -113,7 +113,7 @@ UNMAP_AFTER_INIT void SB16::initialize()
     set_sample_rate(m_sample_rate);
 }
 
-KResult SB16::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
+ErrorOr<void> SB16::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case SOUNDCARD_IOCTL_GET_SAMPLE_RATE: {
@@ -126,7 +126,7 @@ KResult SB16::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg
             return EINVAL;
         if (m_sample_rate != sample_rate_value)
             set_sample_rate(sample_rate_value);
-        return KSuccess;
+        return {};
     }
     default:
         return EINVAL;
@@ -186,7 +186,7 @@ bool SB16::can_read(OpenFileDescription const&, size_t) const
     return false;
 }
 
-KResultOr<size_t> SB16::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
+ErrorOr<size_t> SB16::read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t)
 {
     return 0;
 }
@@ -246,7 +246,7 @@ void SB16::wait_for_irq()
     disable_irq();
 }
 
-KResultOr<size_t> SB16::write(OpenFileDescription&, u64, UserOrKernelBuffer const& data, size_t length)
+ErrorOr<size_t> SB16::write(OpenFileDescription&, u64, UserOrKernelBuffer const& data, size_t length)
 {
     if (!m_dma_region) {
         auto page = MM.allocate_supervisor_physical_page();
diff --git a/Kernel/Devices/SB16.h b/Kernel/Devices/SB16.h
index 54746d9e1ab..fe596b5204a 100644
--- a/Kernel/Devices/SB16.h
+++ b/Kernel/Devices/SB16.h
@@ -27,13 +27,13 @@ public:
 
     // ^CharacterDevice
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
     virtual StringView purpose() const override { return class_name(); }
 
-    virtual KResult ioctl(OpenFileDescription&, unsigned, Userspace<void*>) override;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned, Userspace<void*>) override;
 
 private:
     SB16();
diff --git a/Kernel/Devices/SerialDevice.cpp b/Kernel/Devices/SerialDevice.cpp
index b4f6618d28c..9a21dfb4475 100644
--- a/Kernel/Devices/SerialDevice.cpp
+++ b/Kernel/Devices/SerialDevice.cpp
@@ -61,7 +61,7 @@ bool SerialDevice::can_read(const OpenFileDescription&, size_t) const
     return (get_line_status() & DataReady) != 0;
 }
 
-KResultOr<size_t> SerialDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> SerialDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (!size)
         return 0;
@@ -82,7 +82,7 @@ bool SerialDevice::can_write(const OpenFileDescription&, size_t) const
     return (get_line_status() & EmptyTransmitterHoldingRegister) != 0;
 }
 
-KResultOr<size_t> SerialDevice::write(OpenFileDescription& description, u64, const UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> SerialDevice::write(OpenFileDescription& description, u64, const UserOrKernelBuffer& buffer, size_t size)
 {
     if (!size)
         return 0;
diff --git a/Kernel/Devices/SerialDevice.h b/Kernel/Devices/SerialDevice.h
index 9768f4c96c0..221597f4ab5 100644
--- a/Kernel/Devices/SerialDevice.h
+++ b/Kernel/Devices/SerialDevice.h
@@ -22,9 +22,9 @@ public:
 
     // ^CharacterDevice
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
 
     void put_char(char);
 
diff --git a/Kernel/Devices/ZeroDevice.cpp b/Kernel/Devices/ZeroDevice.cpp
index ed10d1ef39f..400fa511177 100644
--- a/Kernel/Devices/ZeroDevice.cpp
+++ b/Kernel/Devices/ZeroDevice.cpp
@@ -33,13 +33,13 @@ bool ZeroDevice::can_read(const OpenFileDescription&, size_t) const
     return true;
 }
 
-KResultOr<size_t> ZeroDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> ZeroDevice::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     TRY(buffer.memset(0, size));
     return size;
 }
 
-KResultOr<size_t> ZeroDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
+ErrorOr<size_t> ZeroDevice::write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t size)
 {
     return size;
 }
diff --git a/Kernel/Devices/ZeroDevice.h b/Kernel/Devices/ZeroDevice.h
index 33161b326f4..d5c627d1418 100644
--- a/Kernel/Devices/ZeroDevice.h
+++ b/Kernel/Devices/ZeroDevice.h
@@ -22,8 +22,8 @@ private:
     ZeroDevice();
 
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
     virtual StringView class_name() const override { return "ZeroDevice"sv; }
diff --git a/Kernel/DoubleBuffer.cpp b/Kernel/DoubleBuffer.cpp
index c9b8df333b2..ecd90942c70 100644
--- a/Kernel/DoubleBuffer.cpp
+++ b/Kernel/DoubleBuffer.cpp
@@ -17,7 +17,7 @@ inline void DoubleBuffer::compute_lockfree_metadata()
     m_space_for_writing = m_capacity - m_write_buffer->size;
 }
 
-KResultOr<NonnullOwnPtr<DoubleBuffer>> DoubleBuffer::try_create(size_t capacity)
+ErrorOr<NonnullOwnPtr<DoubleBuffer>> DoubleBuffer::try_create(size_t capacity)
 {
     auto storage = TRY(KBuffer::try_create_with_size(capacity * 2, Memory::Region::Access::ReadWrite, "DoubleBuffer"));
     return adopt_nonnull_own_or_enomem(new (nothrow) DoubleBuffer(capacity, move(storage)));
@@ -45,7 +45,7 @@ void DoubleBuffer::flip()
     compute_lockfree_metadata();
 }
 
-KResultOr<size_t> DoubleBuffer::write(const UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> DoubleBuffer::write(const UserOrKernelBuffer& data, size_t size)
 {
     if (!size)
         return 0;
@@ -60,7 +60,7 @@ KResultOr<size_t> DoubleBuffer::write(const UserOrKernelBuffer& data, size_t siz
     return bytes_to_write;
 }
 
-KResultOr<size_t> DoubleBuffer::read(UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> DoubleBuffer::read(UserOrKernelBuffer& data, size_t size)
 {
     if (!size)
         return 0;
@@ -78,7 +78,7 @@ KResultOr<size_t> DoubleBuffer::read(UserOrKernelBuffer& data, size_t size)
     return nread;
 }
 
-KResultOr<size_t> DoubleBuffer::peek(UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> DoubleBuffer::peek(UserOrKernelBuffer& data, size_t size)
 {
     if (!size)
         return 0;
diff --git a/Kernel/DoubleBuffer.h b/Kernel/DoubleBuffer.h
index c826f35fa48..958d537d402 100644
--- a/Kernel/DoubleBuffer.h
+++ b/Kernel/DoubleBuffer.h
@@ -16,20 +16,20 @@ namespace Kernel {
 
 class DoubleBuffer {
 public:
-    static KResultOr<NonnullOwnPtr<DoubleBuffer>> try_create(size_t capacity = 65536);
-    KResultOr<size_t> write(const UserOrKernelBuffer&, size_t);
-    KResultOr<size_t> write(const u8* data, size_t size)
+    static ErrorOr<NonnullOwnPtr<DoubleBuffer>> try_create(size_t capacity = 65536);
+    ErrorOr<size_t> write(const UserOrKernelBuffer&, size_t);
+    ErrorOr<size_t> write(const u8* data, size_t size)
     {
         return write(UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>(data)), size);
     }
-    KResultOr<size_t> read(UserOrKernelBuffer&, size_t);
-    KResultOr<size_t> read(u8* data, size_t size)
+    ErrorOr<size_t> read(UserOrKernelBuffer&, size_t);
+    ErrorOr<size_t> read(u8* data, size_t size)
     {
         auto buffer = UserOrKernelBuffer::for_kernel_buffer(data);
         return read(buffer, size);
     }
-    KResultOr<size_t> peek(UserOrKernelBuffer&, size_t);
-    KResultOr<size_t> peek(u8* data, size_t size)
+    ErrorOr<size_t> peek(UserOrKernelBuffer&, size_t);
+    ErrorOr<size_t> peek(u8* data, size_t size)
     {
         auto buffer = UserOrKernelBuffer::for_kernel_buffer(data);
         return peek(buffer, size);
diff --git a/Kernel/FileSystem/AnonymousFile.cpp b/Kernel/FileSystem/AnonymousFile.cpp
index 81022dda8f6..b3e0a92b708 100644
--- a/Kernel/FileSystem/AnonymousFile.cpp
+++ b/Kernel/FileSystem/AnonymousFile.cpp
@@ -19,7 +19,7 @@ AnonymousFile::~AnonymousFile()
 {
 }
 
-KResultOr<Memory::Region*> AnonymousFile::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+ErrorOr<Memory::Region*> AnonymousFile::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     if (offset != 0)
         return EINVAL;
@@ -30,7 +30,7 @@ KResultOr<Memory::Region*> AnonymousFile::mmap(Process& process, OpenFileDescrip
     return process.address_space().allocate_region_with_vmobject(range, m_vmobject, offset, {}, prot, shared);
 }
 
-KResultOr<NonnullOwnPtr<KString>> AnonymousFile::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> AnonymousFile::pseudo_path(const OpenFileDescription&) const
 {
     return KString::try_create(":anonymous-file:"sv);
 }
diff --git a/Kernel/FileSystem/AnonymousFile.h b/Kernel/FileSystem/AnonymousFile.h
index 49a21e7fc7f..a6e85810c83 100644
--- a/Kernel/FileSystem/AnonymousFile.h
+++ b/Kernel/FileSystem/AnonymousFile.h
@@ -13,22 +13,22 @@ namespace Kernel {
 
 class AnonymousFile final : public File {
 public:
-    static KResultOr<NonnullRefPtr<AnonymousFile>> try_create(NonnullRefPtr<Memory::AnonymousVMObject> vmobject)
+    static ErrorOr<NonnullRefPtr<AnonymousFile>> try_create(NonnullRefPtr<Memory::AnonymousVMObject> vmobject)
     {
         return adopt_nonnull_ref_or_enomem(new (nothrow) AnonymousFile(move(vmobject)));
     }
 
     virtual ~AnonymousFile() override;
 
-    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
 
 private:
     virtual StringView class_name() const override { return "AnonymousFile"sv; }
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const;
     virtual bool can_read(const OpenFileDescription&, size_t) const override { return false; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return false; }
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
 
     explicit AnonymousFile(NonnullRefPtr<Memory::AnonymousVMObject>);
 
diff --git a/Kernel/FileSystem/BlockBasedFileSystem.cpp b/Kernel/FileSystem/BlockBasedFileSystem.cpp
index 346a839e972..2b329a7b9ba 100644
--- a/Kernel/FileSystem/BlockBasedFileSystem.cpp
+++ b/Kernel/FileSystem/BlockBasedFileSystem.cpp
@@ -114,7 +114,7 @@ BlockBasedFileSystem::~BlockBasedFileSystem()
 {
 }
 
-KResult BlockBasedFileSystem::initialize()
+ErrorOr<void> BlockBasedFileSystem::initialize()
 {
     VERIFY(block_size() != 0);
     auto cached_block_data = TRY(KBuffer::try_create_with_size(DiskCache::EntryCount * block_size()));
@@ -124,22 +124,22 @@ KResult BlockBasedFileSystem::initialize()
     m_cache.with_exclusive([&](auto& cache) {
         cache = move(disk_cache);
     });
-    return KSuccess;
+    return {};
 }
 
-KResult BlockBasedFileSystem::write_block(BlockIndex index, const UserOrKernelBuffer& data, size_t count, size_t offset, bool allow_cache)
+ErrorOr<void> BlockBasedFileSystem::write_block(BlockIndex index, const UserOrKernelBuffer& data, size_t count, size_t offset, bool allow_cache)
 {
     VERIFY(m_logical_block_size);
     VERIFY(offset + count <= block_size());
     dbgln_if(BBFS_DEBUG, "BlockBasedFileSystem::write_block {}, size={}", index, count);
 
-    return m_cache.with_exclusive([&](auto& cache) -> KResult {
+    return m_cache.with_exclusive([&](auto& cache) -> ErrorOr<void> {
         if (!allow_cache) {
             flush_specific_block_if_needed(index);
             auto base_offset = index.value() * block_size() + offset;
             auto nwritten = TRY(file_description().write(base_offset, data, count));
             VERIFY(nwritten == count);
-            return KSuccess;
+            return {};
         }
 
         auto& entry = cache->get(index);
@@ -151,7 +151,7 @@ KResult BlockBasedFileSystem::write_block(BlockIndex index, const UserOrKernelBu
 
         cache->mark_dirty(entry);
         entry.has_data = true;
-        return KSuccess;
+        return {};
     });
 }
 
@@ -195,29 +195,29 @@ bool BlockBasedFileSystem::raw_write_blocks(BlockIndex index, size_t count, cons
     return true;
 }
 
-KResult BlockBasedFileSystem::write_blocks(BlockIndex index, unsigned count, const UserOrKernelBuffer& data, bool allow_cache)
+ErrorOr<void> BlockBasedFileSystem::write_blocks(BlockIndex index, unsigned count, const UserOrKernelBuffer& data, bool allow_cache)
 {
     VERIFY(m_logical_block_size);
     dbgln_if(BBFS_DEBUG, "BlockBasedFileSystem::write_blocks {}, count={}", index, count);
     for (unsigned i = 0; i < count; ++i) {
         TRY(write_block(BlockIndex { index.value() + i }, data.offset(i * block_size()), block_size(), 0, allow_cache));
     }
-    return KSuccess;
+    return {};
 }
 
-KResult BlockBasedFileSystem::read_block(BlockIndex index, UserOrKernelBuffer* buffer, size_t count, size_t offset, bool allow_cache) const
+ErrorOr<void> BlockBasedFileSystem::read_block(BlockIndex index, UserOrKernelBuffer* buffer, size_t count, size_t offset, bool allow_cache) const
 {
     VERIFY(m_logical_block_size);
     VERIFY(offset + count <= block_size());
     dbgln_if(BBFS_DEBUG, "BlockBasedFileSystem::read_block {}", index);
 
-    return m_cache.with_exclusive([&](auto& cache) -> KResult {
+    return m_cache.with_exclusive([&](auto& cache) -> ErrorOr<void> {
         if (!allow_cache) {
             const_cast<BlockBasedFileSystem*>(this)->flush_specific_block_if_needed(index);
             auto base_offset = index.value() * block_size() + offset;
             auto nread = TRY(file_description().read(*buffer, base_offset, count));
             VERIFY(nread == count);
-            return KSuccess;
+            return {};
         }
 
         auto& entry = cache->get(index);
@@ -230,11 +230,11 @@ KResult BlockBasedFileSystem::read_block(BlockIndex index, UserOrKernelBuffer* b
         }
         if (buffer)
             TRY(buffer->write(entry.data + offset, count));
-        return KSuccess;
+        return {};
     });
 }
 
-KResult BlockBasedFileSystem::read_blocks(BlockIndex index, unsigned count, UserOrKernelBuffer& buffer, bool allow_cache) const
+ErrorOr<void> BlockBasedFileSystem::read_blocks(BlockIndex index, unsigned count, UserOrKernelBuffer& buffer, bool allow_cache) const
 {
     VERIFY(m_logical_block_size);
     if (!count)
@@ -247,7 +247,7 @@ KResult BlockBasedFileSystem::read_blocks(BlockIndex index, unsigned count, User
         out = out.offset(block_size());
     }
 
-    return KSuccess;
+    return {};
 }
 
 void BlockBasedFileSystem::flush_specific_block_if_needed(BlockIndex index)
diff --git a/Kernel/FileSystem/BlockBasedFileSystem.h b/Kernel/FileSystem/BlockBasedFileSystem.h
index 2e62f652d47..cc0008dd646 100644
--- a/Kernel/FileSystem/BlockBasedFileSystem.h
+++ b/Kernel/FileSystem/BlockBasedFileSystem.h
@@ -16,7 +16,7 @@ public:
     TYPEDEF_DISTINCT_ORDERED_ID(u64, BlockIndex);
 
     virtual ~BlockBasedFileSystem() override;
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
 
     u64 logical_block_size() const { return m_logical_block_size; };
 
@@ -26,8 +26,8 @@ public:
 protected:
     explicit BlockBasedFileSystem(OpenFileDescription&);
 
-    KResult read_block(BlockIndex, UserOrKernelBuffer*, size_t count, size_t offset = 0, bool allow_cache = true) const;
-    KResult read_blocks(BlockIndex, unsigned count, UserOrKernelBuffer&, bool allow_cache = true) const;
+    ErrorOr<void> read_block(BlockIndex, UserOrKernelBuffer*, size_t count, size_t offset = 0, bool allow_cache = true) const;
+    ErrorOr<void> read_blocks(BlockIndex, unsigned count, UserOrKernelBuffer&, bool allow_cache = true) const;
 
     bool raw_read(BlockIndex, UserOrKernelBuffer&);
     bool raw_write(BlockIndex, const UserOrKernelBuffer&);
@@ -35,8 +35,8 @@ protected:
     bool raw_read_blocks(BlockIndex index, size_t count, UserOrKernelBuffer&);
     bool raw_write_blocks(BlockIndex index, size_t count, const UserOrKernelBuffer&);
 
-    KResult write_block(BlockIndex, const UserOrKernelBuffer&, size_t count, size_t offset = 0, bool allow_cache = true);
-    KResult write_blocks(BlockIndex, unsigned count, const UserOrKernelBuffer&, bool allow_cache = true);
+    ErrorOr<void> write_block(BlockIndex, const UserOrKernelBuffer&, size_t count, size_t offset = 0, bool allow_cache = true);
+    ErrorOr<void> write_blocks(BlockIndex, unsigned count, const UserOrKernelBuffer&, bool allow_cache = true);
 
     u64 m_logical_block_size { 512 };
 
diff --git a/Kernel/FileSystem/Custody.cpp b/Kernel/FileSystem/Custody.cpp
index 7e77e514cbd..3e31125fac0 100644
--- a/Kernel/FileSystem/Custody.cpp
+++ b/Kernel/FileSystem/Custody.cpp
@@ -21,15 +21,15 @@ static MutexProtected<Custody::AllCustodiesList>& all_custodies()
     return s_all_custodies;
 }
 
-KResultOr<NonnullRefPtr<Custody>> Custody::try_create(Custody* parent, StringView name, Inode& inode, int mount_flags)
+ErrorOr<NonnullRefPtr<Custody>> Custody::try_create(Custody* parent, StringView name, Inode& inode, int mount_flags)
 {
-    return all_custodies().with_exclusive([&](auto& all_custodies) -> KResultOr<NonnullRefPtr<Custody>> {
+    return all_custodies().with_exclusive([&](auto& all_custodies) -> ErrorOr<NonnullRefPtr<Custody>> {
         for (Custody& custody : all_custodies) {
             if (custody.parent() == parent
                 && custody.name() == name
                 && &custody.inode() == &inode
                 && custody.mount_flags() == mount_flags) {
-                return custody;
+                return NonnullRefPtr { custody };
             }
         }
 
@@ -66,7 +66,7 @@ Custody::~Custody()
 {
 }
 
-KResultOr<NonnullOwnPtr<KString>> Custody::try_serialize_absolute_path() const
+ErrorOr<NonnullOwnPtr<KString>> Custody::try_serialize_absolute_path() const
 {
     if (!parent())
         return KString::try_create("/"sv);
diff --git a/Kernel/FileSystem/Custody.h b/Kernel/FileSystem/Custody.h
index 52e0facf903..e759a83f5db 100644
--- a/Kernel/FileSystem/Custody.h
+++ b/Kernel/FileSystem/Custody.h
@@ -6,11 +6,11 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/IntrusiveList.h>
 #include <AK/RefCounted.h>
 #include <AK/RefPtr.h>
 #include <AK/String.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Forward.h>
 #include <Kernel/Heap/SlabAllocator.h>
 #include <Kernel/KString.h>
@@ -24,7 +24,7 @@ class Custody : public RefCountedBase {
 public:
     bool unref() const;
 
-    static KResultOr<NonnullRefPtr<Custody>> try_create(Custody* parent, StringView name, Inode&, int mount_flags);
+    static ErrorOr<NonnullRefPtr<Custody>> try_create(Custody* parent, StringView name, Inode&, int mount_flags);
 
     ~Custody();
 
@@ -33,7 +33,7 @@ public:
     Inode& inode() { return *m_inode; }
     Inode const& inode() const { return *m_inode; }
     StringView name() const { return m_name->view(); }
-    KResultOr<NonnullOwnPtr<KString>> try_serialize_absolute_path() const;
+    ErrorOr<NonnullOwnPtr<KString>> try_serialize_absolute_path() const;
     String absolute_path() const;
 
     int mount_flags() const { return m_mount_flags; }
diff --git a/Kernel/FileSystem/DevPtsFS.cpp b/Kernel/FileSystem/DevPtsFS.cpp
index b96cb5bf13d..ef49e6b4c06 100644
--- a/Kernel/FileSystem/DevPtsFS.cpp
+++ b/Kernel/FileSystem/DevPtsFS.cpp
@@ -12,7 +12,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<DevPtsFS>> DevPtsFS::try_create()
+ErrorOr<NonnullRefPtr<DevPtsFS>> DevPtsFS::try_create()
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) DevPtsFS);
 }
@@ -25,7 +25,7 @@ DevPtsFS::~DevPtsFS()
 {
 }
 
-KResult DevPtsFS::initialize()
+ErrorOr<void> DevPtsFS::initialize()
 {
     m_root_inode = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) DevPtsFSInode(*this, 1, nullptr)));
     m_root_inode->m_metadata.inode = { fsid(), 1 };
@@ -34,7 +34,7 @@ KResult DevPtsFS::initialize()
     m_root_inode->m_metadata.gid = 0;
     m_root_inode->m_metadata.size = 0;
     m_root_inode->m_metadata.mtime = mepoch;
-    return KSuccess;
+    return {};
 }
 
 static unsigned inode_index_to_pty_index(InodeIndex inode_index)
@@ -53,7 +53,7 @@ Inode& DevPtsFS::root_inode()
     return *m_root_inode;
 }
 
-KResultOr<NonnullRefPtr<Inode>> DevPtsFS::get_inode(InodeIdentifier inode_id) const
+ErrorOr<NonnullRefPtr<Inode>> DevPtsFS::get_inode(InodeIdentifier inode_id) const
 {
     if (inode_id.index() == 1)
         return *m_root_inode;
@@ -85,12 +85,12 @@ DevPtsFSInode::~DevPtsFSInode()
 {
 }
 
-KResultOr<size_t> DevPtsFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
+ErrorOr<size_t> DevPtsFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<size_t> DevPtsFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
+ErrorOr<size_t> DevPtsFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     VERIFY_NOT_REACHED();
 }
@@ -105,7 +105,7 @@ InodeMetadata DevPtsFSInode::metadata() const
     return m_metadata;
 }
 
-KResult DevPtsFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> DevPtsFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     if (identifier().index() > 1)
         return ENOTDIR;
@@ -121,10 +121,10 @@ KResult DevPtsFSInode::traverse_as_directory(Function<bool(FileSystem::Directory
         }
     });
 
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> DevPtsFSInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> DevPtsFSInode::lookup(StringView name)
 {
     VERIFY(identifier().index() == 1);
 
@@ -135,7 +135,7 @@ KResultOr<NonnullRefPtr<Inode>> DevPtsFSInode::lookup(StringView name)
     if (!pty_index.has_value())
         return ENOENT;
 
-    return SlavePTY::all_instances().with([&](auto& list) -> KResultOr<NonnullRefPtr<Inode>> {
+    return SlavePTY::all_instances().with([&](auto& list) -> ErrorOr<NonnullRefPtr<Inode>> {
         for (SlavePTY& slave_pty : list) {
             if (slave_pty.index() != pty_index.value())
                 continue;
@@ -145,32 +145,32 @@ KResultOr<NonnullRefPtr<Inode>> DevPtsFSInode::lookup(StringView name)
     });
 }
 
-KResult DevPtsFSInode::flush_metadata()
+ErrorOr<void> DevPtsFSInode::flush_metadata()
 {
-    return KSuccess;
+    return {};
 }
 
-KResult DevPtsFSInode::add_child(Inode&, const StringView&, mode_t)
+ErrorOr<void> DevPtsFSInode::add_child(Inode&, const StringView&, mode_t)
 {
     return EROFS;
 }
 
-KResultOr<NonnullRefPtr<Inode>> DevPtsFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
+ErrorOr<NonnullRefPtr<Inode>> DevPtsFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
 {
     return EROFS;
 }
 
-KResult DevPtsFSInode::remove_child(const StringView&)
+ErrorOr<void> DevPtsFSInode::remove_child(const StringView&)
 {
     return EROFS;
 }
 
-KResult DevPtsFSInode::chmod(mode_t)
+ErrorOr<void> DevPtsFSInode::chmod(mode_t)
 {
     return EROFS;
 }
 
-KResult DevPtsFSInode::chown(UserID, GroupID)
+ErrorOr<void> DevPtsFSInode::chown(UserID, GroupID)
 {
     return EROFS;
 }
diff --git a/Kernel/FileSystem/DevPtsFS.h b/Kernel/FileSystem/DevPtsFS.h
index e907a521777..9b2f6a02298 100644
--- a/Kernel/FileSystem/DevPtsFS.h
+++ b/Kernel/FileSystem/DevPtsFS.h
@@ -20,16 +20,16 @@ class DevPtsFS final : public FileSystem {
 
 public:
     virtual ~DevPtsFS() override;
-    static KResultOr<NonnullRefPtr<DevPtsFS>> try_create();
+    static ErrorOr<NonnullRefPtr<DevPtsFS>> try_create();
 
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
     virtual StringView class_name() const override { return "DevPtsFS"sv; }
 
     virtual Inode& root_inode() override;
 
 private:
     DevPtsFS();
-    KResultOr<NonnullRefPtr<Inode>> get_inode(InodeIdentifier) const;
+    ErrorOr<NonnullRefPtr<Inode>> get_inode(InodeIdentifier) const;
 
     RefPtr<DevPtsFSInode> m_root_inode;
 };
@@ -47,17 +47,17 @@ private:
     DevPtsFSInode(DevPtsFS&, InodeIndex, SlavePTY*);
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
-    virtual KResult flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
-    virtual KResult remove_child(const StringView& name) override;
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> flush_metadata() override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> add_child(Inode&, const StringView& name, mode_t) override;
+    virtual ErrorOr<void> remove_child(const StringView& name) override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
 
     WeakPtr<SlavePTY> m_pty;
     InodeMetadata m_metadata;
diff --git a/Kernel/FileSystem/DevTmpFS.cpp b/Kernel/FileSystem/DevTmpFS.cpp
index 6793152bb52..2a129153124 100644
--- a/Kernel/FileSystem/DevTmpFS.cpp
+++ b/Kernel/FileSystem/DevTmpFS.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<DevTmpFS>> DevTmpFS::try_create()
+ErrorOr<NonnullRefPtr<DevTmpFS>> DevTmpFS::try_create()
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) DevTmpFS);
 }
@@ -32,10 +32,10 @@ DevTmpFS::~DevTmpFS()
 {
 }
 
-KResult DevTmpFS::initialize()
+ErrorOr<void> DevTmpFS::initialize()
 {
     m_root_inode = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) DevTmpFSRootDirectoryInode(*this)));
-    return KSuccess;
+    return {};
 }
 
 Inode& DevTmpFS::root_inode()
@@ -55,37 +55,37 @@ DevTmpFSInode::DevTmpFSInode(DevTmpFS& fs, unsigned major_number, unsigned minor
 {
 }
 
-KResultOr<size_t> DevTmpFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
+ErrorOr<size_t> DevTmpFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult DevTmpFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
+ErrorOr<void> DevTmpFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<NonnullRefPtr<Inode>> DevTmpFSInode::lookup(StringView)
+ErrorOr<NonnullRefPtr<Inode>> DevTmpFSInode::lookup(StringView)
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult DevTmpFSInode::flush_metadata()
+ErrorOr<void> DevTmpFSInode::flush_metadata()
 {
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> DevTmpFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
+ErrorOr<size_t> DevTmpFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<NonnullRefPtr<Inode>> DevTmpFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
+ErrorOr<NonnullRefPtr<Inode>> DevTmpFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult DevTmpFSInode::add_child(Inode&, const StringView&, mode_t)
+ErrorOr<void> DevTmpFSInode::add_child(Inode&, const StringView&, mode_t)
 {
     VERIFY_NOT_REACHED();
 }
@@ -134,30 +134,30 @@ InodeMetadata DevTmpFSInode::metadata() const
     return metadata;
 }
 
-KResult DevTmpFSInode::remove_child(const StringView&)
+ErrorOr<void> DevTmpFSInode::remove_child(const StringView&)
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult DevTmpFSInode::chmod(mode_t mode)
+ErrorOr<void> DevTmpFSInode::chmod(mode_t mode)
 {
     MutexLocker locker(m_inode_lock);
     mode &= 0777;
     if (m_mode == mode)
-        return KSuccess;
+        return {};
     m_mode = mode;
-    return KSuccess;
+    return {};
 }
 
-KResult DevTmpFSInode::chown(UserID uid, GroupID gid)
+ErrorOr<void> DevTmpFSInode::chown(UserID uid, GroupID gid)
 {
     MutexLocker locker(m_inode_lock);
     m_uid = uid;
     m_gid = gid;
-    return KSuccess;
+    return {};
 }
 
-KResult DevTmpFSInode::truncate(u64)
+ErrorOr<void> DevTmpFSInode::truncate(u64)
 {
     return EPERM;
 }
@@ -177,7 +177,7 @@ DevTmpFSLinkInode::DevTmpFSLinkInode(DevTmpFS& fs, NonnullOwnPtr<KString> name)
 {
 }
 
-KResultOr<size_t> DevTmpFSLinkInode::read_bytes(off_t offset, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> DevTmpFSLinkInode::read_bytes(off_t offset, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(offset == 0);
@@ -186,7 +186,7 @@ KResultOr<size_t> DevTmpFSLinkInode::read_bytes(off_t offset, size_t, UserOrKern
     return m_link->length();
 }
 
-KResultOr<size_t> DevTmpFSLinkInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription*)
+ErrorOr<size_t> DevTmpFSLinkInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription*)
 {
     auto new_string = TRY(buffer.try_copy_into_kstring(count));
 
@@ -210,7 +210,7 @@ DevTmpFSDirectoryInode::~DevTmpFSDirectoryInode()
 {
 }
 
-KResult DevTmpFSDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> DevTmpFSDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(m_inode_lock);
     callback({ ".", identifier(), 0 });
@@ -219,10 +219,10 @@ KResult DevTmpFSDirectoryInode::traverse_as_directory(Function<bool(FileSystem::
         InodeIdentifier identifier = { fsid(), node.index() };
         callback({ node.name(), identifier, 0 });
     }
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> DevTmpFSDirectoryInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> DevTmpFSDirectoryInode::lookup(StringView name)
 {
     MutexLocker locker(m_inode_lock);
     for (auto& node : m_nodes) {
@@ -230,27 +230,27 @@ KResultOr<NonnullRefPtr<Inode>> DevTmpFSDirectoryInode::lookup(StringView name)
             return node;
         }
     }
-    return KResult(ENOENT);
+    return Error::from_errno(ENOENT);
 }
 
-KResult DevTmpFSDirectoryInode::remove_child(const StringView& name)
+ErrorOr<void> DevTmpFSDirectoryInode::remove_child(const StringView& name)
 {
     MutexLocker locker(m_inode_lock);
     for (auto& node : m_nodes) {
         if (node.name() == name) {
             m_nodes.remove(node);
-            return KSuccess;
+            return {};
         }
     }
-    return KResult(ENOENT);
+    return Error::from_errno(ENOENT);
 }
 
-KResultOr<NonnullRefPtr<Inode>> DevTmpFSDirectoryInode::create_child(StringView name, mode_t mode, dev_t device_mode, UserID, GroupID)
+ErrorOr<NonnullRefPtr<Inode>> DevTmpFSDirectoryInode::create_child(StringView name, mode_t mode, dev_t device_mode, UserID, GroupID)
 {
     MutexLocker locker(m_inode_lock);
     for (auto& node : m_nodes) {
         if (node.name() == name)
-            return KResult(EEXIST);
+            return Error::from_errno(EEXIST);
     }
 
     InodeMetadata metadata;
@@ -288,12 +288,12 @@ DevTmpFSRootDirectoryInode::DevTmpFSRootDirectoryInode(DevTmpFS& fs)
 DevTmpFSRootDirectoryInode::~DevTmpFSRootDirectoryInode()
 {
 }
-KResult DevTmpFSRootDirectoryInode::chmod(mode_t)
+ErrorOr<void> DevTmpFSRootDirectoryInode::chmod(mode_t)
 {
     return EPERM;
 }
 
-KResult DevTmpFSRootDirectoryInode::chown(UserID, GroupID)
+ErrorOr<void> DevTmpFSRootDirectoryInode::chown(UserID, GroupID)
 {
     return EPERM;
 }
@@ -314,30 +314,30 @@ StringView DevTmpFSDeviceInode::name() const
     return m_name->view();
 }
 
-KResultOr<size_t> DevTmpFSDeviceInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
+ErrorOr<size_t> DevTmpFSDeviceInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(!!description);
     RefPtr<Device> device = DeviceManagement::the().get_device(m_major_number, m_minor_number);
     if (!device)
-        return KResult(ENODEV);
+        return Error::from_errno(ENODEV);
     if (!device->can_read(*description, offset))
-        return KResult(ENOTIMPL);
+        return Error::from_errno(ENOTIMPL);
     auto result = const_cast<Device&>(*device).read(*description, offset, buffer, count);
     if (result.is_error())
         return result;
     return result.value();
 }
 
-KResultOr<size_t> DevTmpFSDeviceInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* description)
+ErrorOr<size_t> DevTmpFSDeviceInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* description)
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(!!description);
     RefPtr<Device> device = DeviceManagement::the().get_device(m_major_number, m_minor_number);
     if (!device)
-        return KResult(ENODEV);
+        return Error::from_errno(ENODEV);
     if (!device->can_write(*description, offset))
-        return KResult(ENOTIMPL);
+        return Error::from_errno(ENOTIMPL);
     auto result = const_cast<Device&>(*device).write(*description, offset, buffer, count);
     if (result.is_error())
         return result;
diff --git a/Kernel/FileSystem/DevTmpFS.h b/Kernel/FileSystem/DevTmpFS.h
index 418252d6afa..9a203d83a87 100644
--- a/Kernel/FileSystem/DevTmpFS.h
+++ b/Kernel/FileSystem/DevTmpFS.h
@@ -20,9 +20,9 @@ class DevTmpFS final : public FileSystem {
 
 public:
     virtual ~DevTmpFS() override;
-    static KResultOr<NonnullRefPtr<DevTmpFS>> try_create();
+    static ErrorOr<NonnullRefPtr<DevTmpFS>> try_create();
 
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
     virtual StringView class_name() const override { return "DevTmpFS"sv; }
     virtual Inode& root_inode() override;
 
@@ -48,18 +48,18 @@ public:
 protected:
     explicit DevTmpFSInode(DevTmpFS&);
     DevTmpFSInode(DevTmpFS&, unsigned, unsigned);
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
-    virtual KResult flush_metadata() override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> flush_metadata() override;
     virtual InodeMetadata metadata() const override final;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
-    virtual KResult remove_child(const StringView& name) override;
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
-    virtual KResult truncate(u64) override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> add_child(Inode&, const StringView& name, mode_t) override;
+    virtual ErrorOr<void> remove_child(const StringView& name) override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
+    virtual ErrorOr<void> truncate(u64) override;
 
     mode_t m_mode { 0600 };
     UserID m_uid { 0 };
@@ -96,8 +96,8 @@ private:
     virtual Type node_type() const override { return m_block_device ? Type::BlockDevice : Type::CharacterDevice; }
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
 
     NonnullOwnPtr<KString> m_name;
     const bool m_block_device;
@@ -117,8 +117,8 @@ protected:
     virtual Type node_type() const override { return Type::Link; }
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
 
     NonnullOwnPtr<KString> m_name;
     OwnPtr<KString> m_link;
@@ -136,10 +136,10 @@ protected:
     // ^DevTmpFSInode
     virtual Type node_type() const override { return Type::Directory; }
 
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult remove_child(const StringView& name) override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> remove_child(const StringView& name) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
     DevTmpFSDirectoryInode(DevTmpFS&, NonnullOwnPtr<KString> name);
     // ^Inode
     OwnPtr<KString> m_name;
@@ -161,8 +161,8 @@ private:
     virtual Type node_type() const override { return Type::Directory; }
 
     explicit DevTmpFSRootDirectoryInode(DevTmpFS&);
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
 };
 
 }
diff --git a/Kernel/FileSystem/Ext2FileSystem.cpp b/Kernel/FileSystem/Ext2FileSystem.cpp
index 983f8995d35..721d479184f 100644
--- a/Kernel/FileSystem/Ext2FileSystem.cpp
+++ b/Kernel/FileSystem/Ext2FileSystem.cpp
@@ -54,7 +54,7 @@ static unsigned divide_rounded_up(unsigned a, unsigned b)
     return (a / b) + (a % b != 0);
 }
 
-KResultOr<NonnullRefPtr<Ext2FS>> Ext2FS::try_create(OpenFileDescription& file_description)
+ErrorOr<NonnullRefPtr<Ext2FS>> Ext2FS::try_create(OpenFileDescription& file_description)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) Ext2FS(file_description));
 }
@@ -86,7 +86,7 @@ const ext2_group_desc& Ext2FS::group_descriptor(GroupIndex group_index) const
     return block_group_descriptors()[group_index.value() - 1];
 }
 
-KResult Ext2FS::initialize()
+ErrorOr<void> Ext2FS::initialize()
 {
     MutexLocker locker(m_lock);
 
@@ -144,7 +144,7 @@ KResult Ext2FS::initialize()
     }
 
     m_root_inode = static_ptr_cast<Ext2FSInode>(TRY(get_inode({ fsid(), EXT2_ROOT_INO })));
-    return KSuccess;
+    return {};
 }
 
 Ext2FSInode& Ext2FS::root_inode()
@@ -204,7 +204,7 @@ Ext2FS::BlockListShape Ext2FS::compute_block_list_shape(unsigned blocks) const
     return shape;
 }
 
-KResult Ext2FSInode::write_indirect_block(BlockBasedFileSystem::BlockIndex block, Span<BlockBasedFileSystem::BlockIndex> blocks_indices)
+ErrorOr<void> Ext2FSInode::write_indirect_block(BlockBasedFileSystem::BlockIndex block, Span<BlockBasedFileSystem::BlockIndex> blocks_indices)
 {
     const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
     VERIFY(blocks_indices.size() <= entries_per_block);
@@ -224,7 +224,7 @@ KResult Ext2FSInode::write_indirect_block(BlockBasedFileSystem::BlockIndex block
     return fs().write_block(block, buffer, stream.size());
 }
 
-KResult Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, Span<BlockBasedFileSystem::BlockIndex> blocks_indices, Vector<Ext2FS::BlockIndex>& new_meta_blocks, unsigned& meta_blocks)
+ErrorOr<void> Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, Span<BlockBasedFileSystem::BlockIndex> blocks_indices, Vector<Ext2FS::BlockIndex>& new_meta_blocks, unsigned& meta_blocks)
 {
     const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
     const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
@@ -267,7 +267,7 @@ KResult Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex
     return fs().write_block(block, buffer, stream.size());
 }
 
-KResult Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, size_t new_blocks_length, unsigned& meta_blocks)
+ErrorOr<void> Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, size_t new_blocks_length, unsigned& meta_blocks)
 {
     const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
     const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
@@ -299,10 +299,10 @@ KResult Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFileSystem::BlockInd
         meta_blocks--;
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, Span<BlockBasedFileSystem::BlockIndex> blocks_indices, Vector<Ext2FS::BlockIndex>& new_meta_blocks, unsigned& meta_blocks)
+ErrorOr<void> Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, Span<BlockBasedFileSystem::BlockIndex> blocks_indices, Vector<Ext2FS::BlockIndex>& new_meta_blocks, unsigned& meta_blocks)
 {
     const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
     const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
@@ -348,7 +348,7 @@ KResult Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex
     return fs().write_block(block, buffer, stream.size());
 }
 
-KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, size_t new_blocks_length, unsigned& meta_blocks)
+ErrorOr<void> Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, size_t new_blocks_length, unsigned& meta_blocks)
 {
     const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
     const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
@@ -383,10 +383,10 @@ KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::BlockInd
         meta_blocks--;
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::flush_block_list()
+ErrorOr<void> Ext2FSInode::flush_block_list()
 {
     MutexLocker locker(m_inode_lock);
 
@@ -394,7 +394,7 @@ KResult Ext2FSInode::flush_block_list()
         m_raw_inode.i_blocks = 0;
         memset(m_raw_inode.i_block, 0, sizeof(m_raw_inode.i_block));
         set_metadata_dirty(true);
-        return KSuccess;
+        return {};
     }
 
     // NOTE: There is a mismatch between i_blocks and blocks.size() since i_blocks includes meta blocks and blocks.size() does not.
@@ -512,7 +512,7 @@ KResult Ext2FSInode::flush_block_list()
     VERIFY(new_meta_blocks.size() == 0);
     VERIFY(old_shape.meta_blocks == new_shape.meta_blocks);
     if (!remaining_blocks)
-        return KSuccess;
+        return {};
 
     dbgln("we don't know how to write qind ext2fs blocks, they don't exist anyway!");
     VERIFY_NOT_REACHED();
@@ -633,7 +633,7 @@ Vector<Ext2FS::BlockIndex> Ext2FSInode::compute_block_list_impl_internal(const e
     return list;
 }
 
-KResult Ext2FS::free_inode(Ext2FSInode& inode)
+ErrorOr<void> Ext2FS::free_inode(Ext2FSInode& inode)
 {
     MutexLocker locker(m_lock);
     VERIFY(inode.m_raw_inode.i_links_count == 0);
@@ -662,7 +662,7 @@ KResult Ext2FS::free_inode(Ext2FSInode& inode)
     // Mark the inode as free.
     TRY(set_inode_allocation_state(inode.index(), false));
 
-    return KSuccess;
+    return {};
 }
 
 void Ext2FS::flush_block_group_descriptor_table()
@@ -773,7 +773,7 @@ InodeMetadata Ext2FSInode::metadata() const
     return metadata;
 }
 
-KResult Ext2FSInode::flush_metadata()
+ErrorOr<void> Ext2FSInode::flush_metadata()
 {
     MutexLocker locker(m_inode_lock);
     dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::flush_metadata(): Flushing inode", identifier());
@@ -786,10 +786,10 @@ KResult Ext2FSInode::flush_metadata()
         }
     }
     set_metadata_dirty(false);
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> Ext2FS::get_inode(InodeIdentifier inode) const
+ErrorOr<NonnullRefPtr<Inode>> Ext2FS::get_inode(InodeIdentifier inode) const
 {
     MutexLocker locker(m_lock);
     VERIFY(inode.fsid() == fsid());
@@ -799,7 +799,7 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FS::get_inode(InodeIdentifier inode) const
         if (it != m_inode_cache.end()) {
             if (!it->value)
                 return ENOENT;
-            return *it->value;
+            return NonnullRefPtr<Inode> { *it->value };
         }
     }
 
@@ -824,7 +824,7 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FS::get_inode(InodeIdentifier inode) const
     return new_inode;
 }
 
-KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
+ErrorOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     MutexLocker inode_locker(m_inode_lock);
     VERIFY(offset >= 0);
@@ -878,7 +878,7 @@ KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKern
         } else {
             if (auto result = fs().read_block(block_index, &buffer_offset, num_bytes_to_copy, offset_into_block, allow_cache); result.is_error()) {
                 dmesgln("Ext2FSInode[{}]::read_bytes(): Failed to read block {} (index {})", identifier(), block_index.value(), bi);
-                return result.error();
+                return result.release_error();
             }
         }
         remaining_count -= num_bytes_to_copy;
@@ -888,11 +888,11 @@ KResultOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKern
     return nread;
 }
 
-KResult Ext2FSInode::resize(u64 new_size)
+ErrorOr<void> Ext2FSInode::resize(u64 new_size)
 {
     auto old_size = size();
     if (old_size == new_size)
-        return KSuccess;
+        return {};
 
     if (!((u32)fs().get_features_readonly() & (u32)Ext2FS::FeaturesReadOnly::FileSize64bits) && (new_size >= static_cast<u32>(-1)))
         return ENOSPC;
@@ -959,10 +959,10 @@ KResult Ext2FSInode::resize(u64 new_size)
         }
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& data, OpenFileDescription* description)
+ErrorOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& data, OpenFileDescription* description)
 {
     VERIFY(offset >= 0);
 
@@ -1018,7 +1018,7 @@ KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const Use
         dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::write_bytes(): Writing block {} (offset_into_block: {})", identifier(), m_block_list[bi.value()], offset_into_block);
         if (auto result = fs().write_block(m_block_list[bi.value()], data.offset(nwritten), num_bytes_to_copy, offset_into_block, allow_cache); result.is_error()) {
             dbgln("Ext2FSInode[{}]::write_bytes(): Failed to write block {} (index {})", identifier(), m_block_list[bi.value()], bi);
-            return result;
+            return result.release_error();
         }
         remaining_count -= num_bytes_to_copy;
         nwritten += num_bytes_to_copy;
@@ -1059,7 +1059,7 @@ Ext2FS::FeaturesReadOnly Ext2FS::get_features_readonly() const
     return Ext2FS::FeaturesReadOnly::None;
 }
 
-KResult Ext2FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> Ext2FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     VERIFY(is_directory());
 
@@ -1081,16 +1081,16 @@ KResult Ext2FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEn
             if (entry->inode != 0) {
                 dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::traverse_as_directory(): inode {}, name_len: {}, rec_len: {}, file_type: {}, name: {}", identifier(), entry->inode, entry->name_len, entry->rec_len, entry->file_type, StringView(entry->name, entry->name_len));
                 if (!callback({ { entry->name, entry->name_len }, { fsid(), entry->inode }, entry->file_type }))
-                    return KSuccess;
+                    return {};
             }
             entry = (ext2_dir_entry_2*)((char*)entry + entry->rec_len);
         }
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::write_directory(Vector<Ext2FSDirectoryEntry>& entries)
+ErrorOr<void> Ext2FSInode::write_directory(Vector<Ext2FSDirectoryEntry>& entries)
 {
     MutexLocker locker(m_inode_lock);
     auto block_size = fs().block_size();
@@ -1147,17 +1147,17 @@ KResult Ext2FSInode::write_directory(Vector<Ext2FSDirectoryEntry>& entries)
     set_metadata_dirty(true);
     if (nwritten != directory_data.size())
         return EIO;
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> Ext2FSInode::create_child(StringView name, mode_t mode, dev_t dev, UserID uid, GroupID gid)
+ErrorOr<NonnullRefPtr<Inode>> Ext2FSInode::create_child(StringView name, mode_t mode, dev_t dev, UserID uid, GroupID gid)
 {
     if (::is_directory(mode))
         return fs().create_directory(*this, name, mode, uid, gid);
     return fs().create_inode(*this, name, mode, dev, uid, gid);
 }
 
-KResult Ext2FSInode::add_child(Inode& child, const StringView& name, mode_t mode)
+ErrorOr<void> Ext2FSInode::add_child(Inode& child, const StringView& name, mode_t mode)
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(is_directory());
@@ -1192,10 +1192,10 @@ KResult Ext2FSInode::add_child(Inode& child, const StringView& name, mode_t mode
 
     m_lookup_cache.set(name, child.index());
     did_add_child(child.identifier(), name);
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::remove_child(const StringView& name)
+ErrorOr<void> Ext2FSInode::remove_child(const StringView& name)
 {
     MutexLocker locker(m_inode_lock);
     dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::remove_child(): Removing '{}'", identifier(), name);
@@ -1225,7 +1225,7 @@ KResult Ext2FSInode::remove_child(const StringView& name)
     TRY(child_inode->decrement_link_count());
 
     did_remove_child(child_id, name);
-    return KSuccess;
+    return {};
 }
 
 u64 Ext2FS::inodes_per_block() const
@@ -1247,7 +1247,7 @@ u64 Ext2FS::blocks_per_group() const
     return EXT2_BLOCKS_PER_GROUP(&super_block());
 }
 
-KResult Ext2FS::write_ext2_inode(InodeIndex inode, ext2_inode const& e2inode)
+ErrorOr<void> Ext2FS::write_ext2_inode(InodeIndex inode, ext2_inode const& e2inode)
 {
     BlockIndex block_index;
     unsigned offset;
@@ -1257,7 +1257,7 @@ KResult Ext2FS::write_ext2_inode(InodeIndex inode, ext2_inode const& e2inode)
     return write_block(block_index, buffer, inode_size(), offset);
 }
 
-auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) -> KResultOr<Vector<BlockIndex>>
+auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) -> ErrorOr<Vector<BlockIndex>>
 {
     dbgln_if(EXT2_DEBUG, "Ext2FS: allocate_blocks(preferred group: {}, count {})", preferred_group_index, count);
     if (count == 0)
@@ -1304,10 +1304,7 @@ auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) ->
         dbgln_if(EXT2_DEBUG, "Ext2FS: allocating free region of size: {} [{}]", free_region_size, group_index);
         for (size_t i = 0; i < free_region_size; ++i) {
             BlockIndex block_index = (first_unset_bit_index.value() + i) + first_block_in_group.value();
-            if (auto result = set_block_allocation_state(block_index, true); result.is_error()) {
-                dbgln("Ext2FS: Failed to allocate block {} in allocate_blocks()", block_index);
-                return result;
-            }
+            TRY(set_block_allocation_state(block_index, true));
             blocks.unchecked_append(block_index);
             dbgln_if(EXT2_DEBUG, "  allocated > {}", block_index);
         }
@@ -1317,7 +1314,7 @@ auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) ->
     return blocks;
 }
 
-KResultOr<InodeIndex> Ext2FS::allocate_inode(GroupIndex preferred_group)
+ErrorOr<InodeIndex> Ext2FS::allocate_inode(GroupIndex preferred_group)
 {
     dbgln_if(EXT2_DEBUG, "Ext2FS: allocate_inode(preferred_group: {})", preferred_group);
     MutexLocker locker(m_lock);
@@ -1391,7 +1388,7 @@ auto Ext2FS::group_index_from_inode(InodeIndex inode) const -> GroupIndex
     return (inode.value() - 1) / inodes_per_group() + 1;
 }
 
-KResultOr<bool> Ext2FS::get_inode_allocation_state(InodeIndex index) const
+ErrorOr<bool> Ext2FS::get_inode_allocation_state(InodeIndex index) const
 {
     MutexLocker locker(m_lock);
     if (index == 0)
@@ -1405,7 +1402,7 @@ KResultOr<bool> Ext2FS::get_inode_allocation_state(InodeIndex index) const
     return cached_bitmap->bitmap(inodes_per_group()).get(bit_index);
 }
 
-KResult Ext2FS::update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter)
+ErrorOr<void> Ext2FS::update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter)
 {
     auto* cached_bitmap = TRY(get_bitmap_block(bitmap_block));
     bool current_state = cached_bitmap->bitmap(blocks_per_group()).get(bit_index);
@@ -1426,10 +1423,10 @@ KResult Ext2FS::update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, b
 
     m_super_block_dirty = true;
     m_block_group_descriptors_dirty = true;
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FS::set_inode_allocation_state(InodeIndex inode_index, bool new_state)
+ErrorOr<void> Ext2FS::set_inode_allocation_state(InodeIndex inode_index, bool new_state)
 {
     MutexLocker locker(m_lock);
     auto group_index = group_index_from_inode(inode_index);
@@ -1446,26 +1443,23 @@ Ext2FS::BlockIndex Ext2FS::first_block_index() const
     return block_size() == 1024 ? 1 : 0;
 }
 
-KResultOr<Ext2FS::CachedBitmap*> Ext2FS::get_bitmap_block(BlockIndex bitmap_block_index)
+ErrorOr<Ext2FS::CachedBitmap*> Ext2FS::get_bitmap_block(BlockIndex bitmap_block_index)
 {
     for (auto& cached_bitmap : m_cached_bitmaps) {
         if (cached_bitmap->bitmap_block_index == bitmap_block_index)
-            return cached_bitmap;
+            return cached_bitmap.ptr();
     }
 
     auto block = TRY(KBuffer::try_create_with_size(block_size(), Memory::Region::Access::ReadWrite, "Ext2FS: Cached bitmap block"));
     auto buffer = UserOrKernelBuffer::for_kernel_buffer(block->data());
-    if (auto result = read_block(bitmap_block_index, &buffer, block_size()); result.is_error()) {
-        dbgln("Ext2FS: Failed to load bitmap block {}", bitmap_block_index);
-        return result;
-    }
+    TRY(read_block(bitmap_block_index, &buffer, block_size()));
     auto new_bitmap = TRY(adopt_nonnull_own_or_enomem(new (nothrow) CachedBitmap(bitmap_block_index, move(block))));
     if (!m_cached_bitmaps.try_append(move(new_bitmap)))
         return ENOMEM;
-    return m_cached_bitmaps.last();
+    return m_cached_bitmaps.last().ptr();
 }
 
-KResult Ext2FS::set_block_allocation_state(BlockIndex block_index, bool new_state)
+ErrorOr<void> Ext2FS::set_block_allocation_state(BlockIndex block_index, bool new_state)
 {
     VERIFY(block_index != 0);
     MutexLocker locker(m_lock);
@@ -1479,7 +1473,7 @@ KResult Ext2FS::set_block_allocation_state(BlockIndex block_index, bool new_stat
     return update_bitmap_block(bgd.bg_block_bitmap, bit_index, new_state, m_super_block.s_free_blocks_count, bgd.bg_free_blocks_count);
 }
 
-KResult Ext2FS::create_directory(Ext2FSInode& parent_inode, StringView name, mode_t mode, UserID uid, GroupID gid)
+ErrorOr<NonnullRefPtr<Inode>> Ext2FS::create_directory(Ext2FSInode& parent_inode, StringView name, mode_t mode, UserID uid, GroupID gid)
 {
     MutexLocker locker(m_lock);
     VERIFY(is_directory(mode));
@@ -1499,10 +1493,10 @@ KResult Ext2FS::create_directory(Ext2FSInode& parent_inode, StringView name, mod
     ++bgd.bg_used_dirs_count;
     m_block_group_descriptors_dirty = true;
 
-    return KSuccess;
+    return inode;
 }
 
-KResultOr<NonnullRefPtr<Inode>> Ext2FS::create_inode(Ext2FSInode& parent_inode, StringView name, mode_t mode, dev_t dev, UserID uid, GroupID gid)
+ErrorOr<NonnullRefPtr<Inode>> Ext2FS::create_inode(Ext2FSInode& parent_inode, StringView name, mode_t mode, dev_t dev, UserID uid, GroupID gid)
 {
     if (name.length() > EXT2_NAME_LEN)
         return ENAMETOOLONG;
@@ -1542,11 +1536,11 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FS::create_inode(Ext2FSInode& parent_inode,
     return new_inode;
 }
 
-KResult Ext2FSInode::populate_lookup_cache() const
+ErrorOr<void> Ext2FSInode::populate_lookup_cache() const
 {
     MutexLocker locker(m_inode_lock);
     if (!m_lookup_cache.is_empty())
-        return KSuccess;
+        return {};
     HashMap<String, InodeIndex> children;
 
     TRY(traverse_as_directory([&children](auto& entry) {
@@ -1556,10 +1550,10 @@ KResult Ext2FSInode::populate_lookup_cache() const
 
     VERIFY(m_lookup_cache.is_empty());
     m_lookup_cache = move(children);
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> Ext2FSInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> Ext2FSInode::lookup(StringView name)
 {
     VERIFY(is_directory());
     dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]:lookup(): Looking up '{}'", identifier(), name);
@@ -1584,37 +1578,37 @@ void Ext2FSInode::one_ref_left()
     // FIXME: I would like to not live forever, but uncached Ext2FS is fucking painful right now.
 }
 
-KResult Ext2FSInode::set_atime(time_t t)
+ErrorOr<void> Ext2FSInode::set_atime(time_t t)
 {
     MutexLocker locker(m_inode_lock);
     if (fs().is_readonly())
         return EROFS;
     m_raw_inode.i_atime = t;
     set_metadata_dirty(true);
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::set_ctime(time_t t)
+ErrorOr<void> Ext2FSInode::set_ctime(time_t t)
 {
     MutexLocker locker(m_inode_lock);
     if (fs().is_readonly())
         return EROFS;
     m_raw_inode.i_ctime = t;
     set_metadata_dirty(true);
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::set_mtime(time_t t)
+ErrorOr<void> Ext2FSInode::set_mtime(time_t t)
 {
     MutexLocker locker(m_inode_lock);
     if (fs().is_readonly())
         return EROFS;
     m_raw_inode.i_mtime = t;
     set_metadata_dirty(true);
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::increment_link_count()
+ErrorOr<void> Ext2FSInode::increment_link_count()
 {
     MutexLocker locker(m_inode_lock);
     if (fs().is_readonly())
@@ -1624,10 +1618,10 @@ KResult Ext2FSInode::increment_link_count()
         return EMLINK;
     ++m_raw_inode.i_links_count;
     set_metadata_dirty(true);
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::decrement_link_count()
+ErrorOr<void> Ext2FSInode::decrement_link_count()
 {
     MutexLocker locker(m_inode_lock);
     if (fs().is_readonly())
@@ -1642,7 +1636,7 @@ KResult Ext2FSInode::decrement_link_count()
     if (ref_count() == 1 && m_raw_inode.i_links_count == 0)
         fs().uncache_inode(index());
 
-    return KSuccess;
+    return {};
 }
 
 void Ext2FS::uncache_inode(InodeIndex index)
@@ -1651,38 +1645,38 @@ void Ext2FS::uncache_inode(InodeIndex index)
     m_inode_cache.remove(index);
 }
 
-KResult Ext2FSInode::chmod(mode_t mode)
+ErrorOr<void> Ext2FSInode::chmod(mode_t mode)
 {
     MutexLocker locker(m_inode_lock);
     if (m_raw_inode.i_mode == mode)
-        return KSuccess;
+        return {};
     m_raw_inode.i_mode = mode;
     set_metadata_dirty(true);
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::chown(UserID uid, GroupID gid)
+ErrorOr<void> Ext2FSInode::chown(UserID uid, GroupID gid)
 {
     MutexLocker locker(m_inode_lock);
     if (m_raw_inode.i_uid == uid && m_raw_inode.i_gid == gid)
-        return KSuccess;
+        return {};
     m_raw_inode.i_uid = uid.value();
     m_raw_inode.i_gid = gid.value();
     set_metadata_dirty(true);
-    return KSuccess;
+    return {};
 }
 
-KResult Ext2FSInode::truncate(u64 size)
+ErrorOr<void> Ext2FSInode::truncate(u64 size)
 {
     MutexLocker locker(m_inode_lock);
     if (static_cast<u64>(m_raw_inode.i_size) == size)
-        return KSuccess;
+        return {};
     TRY(resize(size));
     set_metadata_dirty(true);
-    return KSuccess;
+    return {};
 }
 
-KResultOr<int> Ext2FSInode::get_block_address(int index)
+ErrorOr<int> Ext2FSInode::get_block_address(int index)
 {
     MutexLocker locker(m_inode_lock);
 
@@ -1719,7 +1713,7 @@ unsigned Ext2FS::free_inode_count() const
     return super_block().s_free_inodes_count;
 }
 
-KResult Ext2FS::prepare_to_unmount()
+ErrorOr<void> Ext2FS::prepare_to_unmount()
 {
     MutexLocker locker(m_lock);
 
@@ -1730,6 +1724,6 @@ KResult Ext2FS::prepare_to_unmount()
 
     m_inode_cache.clear();
     m_root_inode = nullptr;
-    return KSuccess;
+    return {};
 }
 }
diff --git a/Kernel/FileSystem/Ext2FileSystem.h b/Kernel/FileSystem/Ext2FileSystem.h
index b09e04bd722..bf220ee454d 100644
--- a/Kernel/FileSystem/Ext2FileSystem.h
+++ b/Kernel/FileSystem/Ext2FileSystem.h
@@ -38,34 +38,34 @@ public:
 
 private:
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
-    virtual KResult flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult add_child(Inode& child, const StringView& name, mode_t) override;
-    virtual KResult remove_child(const StringView& name) override;
-    virtual KResult set_atime(time_t) override;
-    virtual KResult set_ctime(time_t) override;
-    virtual KResult set_mtime(time_t) override;
-    virtual KResult increment_link_count() override;
-    virtual KResult decrement_link_count() override;
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
-    virtual KResult truncate(u64) override;
-    virtual KResultOr<int> get_block_address(int) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> flush_metadata() override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> add_child(Inode& child, const StringView& name, mode_t) override;
+    virtual ErrorOr<void> remove_child(const StringView& name) override;
+    virtual ErrorOr<void> set_atime(time_t) override;
+    virtual ErrorOr<void> set_ctime(time_t) override;
+    virtual ErrorOr<void> set_mtime(time_t) override;
+    virtual ErrorOr<void> increment_link_count() override;
+    virtual ErrorOr<void> decrement_link_count() override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
+    virtual ErrorOr<void> truncate(u64) override;
+    virtual ErrorOr<int> get_block_address(int) override;
 
-    KResult write_directory(Vector<Ext2FSDirectoryEntry>&);
-    KResult populate_lookup_cache() const;
-    KResult resize(u64);
-    KResult write_indirect_block(BlockBasedFileSystem::BlockIndex, Span<BlockBasedFileSystem::BlockIndex>);
-    KResult grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, Span<BlockBasedFileSystem::BlockIndex>, Vector<BlockBasedFileSystem::BlockIndex>&, unsigned&);
-    KResult shrink_doubly_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, size_t, unsigned&);
-    KResult grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, Span<BlockBasedFileSystem::BlockIndex>, Vector<BlockBasedFileSystem::BlockIndex>&, unsigned&);
-    KResult shrink_triply_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, size_t, unsigned&);
-    KResult flush_block_list();
+    ErrorOr<void> write_directory(Vector<Ext2FSDirectoryEntry>&);
+    ErrorOr<void> populate_lookup_cache() const;
+    ErrorOr<void> resize(u64);
+    ErrorOr<void> write_indirect_block(BlockBasedFileSystem::BlockIndex, Span<BlockBasedFileSystem::BlockIndex>);
+    ErrorOr<void> grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, Span<BlockBasedFileSystem::BlockIndex>, Vector<BlockBasedFileSystem::BlockIndex>&, unsigned&);
+    ErrorOr<void> shrink_doubly_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, size_t, unsigned&);
+    ErrorOr<void> grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, Span<BlockBasedFileSystem::BlockIndex>, Vector<BlockBasedFileSystem::BlockIndex>&, unsigned&);
+    ErrorOr<void> shrink_triply_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, size_t, unsigned&);
+    ErrorOr<void> flush_block_list();
     Vector<BlockBasedFileSystem::BlockIndex> compute_block_list() const;
     Vector<BlockBasedFileSystem::BlockIndex> compute_block_list_with_meta_blocks() const;
     Vector<BlockBasedFileSystem::BlockIndex> compute_block_list_impl(bool include_block_list_blocks) const;
@@ -89,17 +89,17 @@ public:
         FileSize64bits = 1 << 1,
     };
 
-    static KResultOr<NonnullRefPtr<Ext2FS>> try_create(OpenFileDescription&);
+    static ErrorOr<NonnullRefPtr<Ext2FS>> try_create(OpenFileDescription&);
 
     virtual ~Ext2FS() override;
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
 
     virtual unsigned total_block_count() const override;
     virtual unsigned free_block_count() const override;
     virtual unsigned total_inode_count() const override;
     virtual unsigned free_inode_count() const override;
 
-    virtual KResult prepare_to_unmount() override;
+    virtual ErrorOr<void> prepare_to_unmount() override;
 
     virtual bool supports_watchers() const override { return true; }
 
@@ -122,30 +122,30 @@ private:
     u64 blocks_per_group() const;
     u64 inode_size() const;
 
-    KResult write_ext2_inode(InodeIndex, ext2_inode const&);
+    ErrorOr<void> write_ext2_inode(InodeIndex, ext2_inode const&);
     bool find_block_containing_inode(InodeIndex, BlockIndex& block_index, unsigned& offset) const;
 
     bool flush_super_block();
 
     virtual StringView class_name() const override { return "Ext2FS"sv; }
     virtual Ext2FSInode& root_inode() override;
-    KResultOr<NonnullRefPtr<Inode>> get_inode(InodeIdentifier) const;
-    KResultOr<NonnullRefPtr<Inode>> create_inode(Ext2FSInode& parent_inode, StringView name, mode_t, dev_t, UserID, GroupID);
-    KResult create_directory(Ext2FSInode& parent_inode, StringView name, mode_t, UserID, GroupID);
+    ErrorOr<NonnullRefPtr<Inode>> get_inode(InodeIdentifier) const;
+    ErrorOr<NonnullRefPtr<Inode>> create_inode(Ext2FSInode& parent_inode, StringView name, mode_t, dev_t, UserID, GroupID);
+    ErrorOr<NonnullRefPtr<Inode>> create_directory(Ext2FSInode& parent_inode, StringView name, mode_t, UserID, GroupID);
     virtual void flush_writes() override;
 
     BlockIndex first_block_index() const;
-    KResultOr<InodeIndex> allocate_inode(GroupIndex preferred_group = 0);
-    KResultOr<Vector<BlockIndex>> allocate_blocks(GroupIndex preferred_group_index, size_t count);
+    ErrorOr<InodeIndex> allocate_inode(GroupIndex preferred_group = 0);
+    ErrorOr<Vector<BlockIndex>> allocate_blocks(GroupIndex preferred_group_index, size_t count);
     GroupIndex group_index_from_inode(InodeIndex) const;
     GroupIndex group_index_from_block_index(BlockIndex) const;
 
-    KResultOr<bool> get_inode_allocation_state(InodeIndex) const;
-    KResult set_inode_allocation_state(InodeIndex, bool);
-    KResult set_block_allocation_state(BlockIndex, bool);
+    ErrorOr<bool> get_inode_allocation_state(InodeIndex) const;
+    ErrorOr<void> set_inode_allocation_state(InodeIndex, bool);
+    ErrorOr<void> set_block_allocation_state(BlockIndex, bool);
 
     void uncache_inode(InodeIndex);
-    KResult free_inode(Ext2FSInode&);
+    ErrorOr<void> free_inode(Ext2FSInode&);
 
     struct BlockListShape {
         unsigned direct_blocks { 0 };
@@ -179,8 +179,8 @@ private:
         BitmapView bitmap(u32 blocks_per_group) { return BitmapView { buffer->data(), blocks_per_group }; }
     };
 
-    KResultOr<CachedBitmap*> get_bitmap_block(BlockIndex);
-    KResult update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter);
+    ErrorOr<CachedBitmap*> get_bitmap_block(BlockIndex);
+    ErrorOr<void> update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter);
 
     Vector<OwnPtr<CachedBitmap>> m_cached_bitmaps;
     RefPtr<Ext2FSInode> m_root_inode;
diff --git a/Kernel/FileSystem/FIFO.cpp b/Kernel/FileSystem/FIFO.cpp
index 2d1e5850434..1fadae8c6b4 100644
--- a/Kernel/FileSystem/FIFO.cpp
+++ b/Kernel/FileSystem/FIFO.cpp
@@ -16,13 +16,13 @@ namespace Kernel {
 
 static Atomic<int> s_next_fifo_id = 1;
 
-KResultOr<NonnullRefPtr<FIFO>> FIFO::try_create(UserID uid)
+ErrorOr<NonnullRefPtr<FIFO>> FIFO::try_create(UserID uid)
 {
     auto buffer = TRY(DoubleBuffer::try_create());
     return adopt_nonnull_ref_or_enomem(new (nothrow) FIFO(uid, move(buffer)));
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> FIFO::open_direction(FIFO::Direction direction)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> FIFO::open_direction(FIFO::Direction direction)
 {
     auto description = TRY(OpenFileDescription::try_create(*this));
     attach(direction);
@@ -30,7 +30,7 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> FIFO::open_direction(FIFO::Directi
     return description;
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> FIFO::open_direction_blocking(FIFO::Direction direction)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> FIFO::open_direction_blocking(FIFO::Direction direction)
 {
     MutexLocker locker(m_open_lock);
 
@@ -109,7 +109,7 @@ bool FIFO::can_write(const OpenFileDescription&, size_t) const
     return m_buffer->space_for_writing() || !m_readers;
 }
 
-KResultOr<size_t> FIFO::read(OpenFileDescription& fd, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> FIFO::read(OpenFileDescription& fd, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (m_buffer->is_empty()) {
         if (!m_writers)
@@ -120,7 +120,7 @@ KResultOr<size_t> FIFO::read(OpenFileDescription& fd, u64, UserOrKernelBuffer& b
     return m_buffer->read(buffer, size);
 }
 
-KResultOr<size_t> FIFO::write(OpenFileDescription& fd, u64, const UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> FIFO::write(OpenFileDescription& fd, u64, const UserOrKernelBuffer& buffer, size_t size)
 {
     if (!m_readers) {
         Thread::current()->send_signal(SIGPIPE, &Process::current());
@@ -132,16 +132,16 @@ KResultOr<size_t> FIFO::write(OpenFileDescription& fd, u64, const UserOrKernelBu
     return m_buffer->write(buffer, size);
 }
 
-KResultOr<NonnullOwnPtr<KString>> FIFO::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> FIFO::pseudo_path(const OpenFileDescription&) const
 {
     return KString::try_create(String::formatted("fifo:{}", m_fifo_id));
 }
 
-KResult FIFO::stat(::stat& st) const
+ErrorOr<void> FIFO::stat(::stat& st) const
 {
     memset(&st, 0, sizeof(st));
     st.st_mode = S_IFIFO;
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/FileSystem/FIFO.h b/Kernel/FileSystem/FIFO.h
index 63523608632..9c20a814526 100644
--- a/Kernel/FileSystem/FIFO.h
+++ b/Kernel/FileSystem/FIFO.h
@@ -24,13 +24,13 @@ public:
         Writer
     };
 
-    static KResultOr<NonnullRefPtr<FIFO>> try_create(UserID);
+    static ErrorOr<NonnullRefPtr<FIFO>> try_create(UserID);
     virtual ~FIFO() override;
 
     UserID uid() const { return m_uid; }
 
-    KResultOr<NonnullRefPtr<OpenFileDescription>> open_direction(Direction);
-    KResultOr<NonnullRefPtr<OpenFileDescription>> open_direction_blocking(Direction);
+    ErrorOr<NonnullRefPtr<OpenFileDescription>> open_direction(Direction);
+    ErrorOr<NonnullRefPtr<OpenFileDescription>> open_direction_blocking(Direction);
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Woverloaded-virtual"
@@ -40,12 +40,12 @@ public:
 
 private:
     // ^File
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResult stat(::stat&) const override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<void> stat(::stat&) const override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
     virtual StringView class_name() const override { return "FIFO"sv; }
     virtual bool is_fifo() const override { return true; }
 
diff --git a/Kernel/FileSystem/File.cpp b/Kernel/FileSystem/File.cpp
index fd98a3a6290..527d48d9222 100644
--- a/Kernel/FileSystem/File.cpp
+++ b/Kernel/FileSystem/File.cpp
@@ -29,7 +29,7 @@ bool File::unref() const
     return true;
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> File::open(int options)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> File::open(int options)
 {
     auto description = OpenFileDescription::try_create(*this);
     if (!description.is_error()) {
@@ -39,25 +39,25 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> File::open(int options)
     return description;
 }
 
-KResult File::close()
+ErrorOr<void> File::close()
 {
-    return KSuccess;
+    return {};
 }
 
-KResult File::ioctl(OpenFileDescription&, unsigned, Userspace<void*>)
+ErrorOr<void> File::ioctl(OpenFileDescription&, unsigned, Userspace<void*>)
 {
     return ENOTTY;
 }
 
-KResultOr<Memory::Region*> File::mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64, int, bool)
+ErrorOr<Memory::Region*> File::mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64, int, bool)
 {
     return ENODEV;
 }
 
-KResult File::attach(OpenFileDescription&)
+ErrorOr<void> File::attach(OpenFileDescription&)
 {
     m_attach_count++;
-    return KSuccess;
+    return {};
 }
 
 void File::detach(OpenFileDescription&)
diff --git a/Kernel/FileSystem/File.h b/Kernel/FileSystem/File.h
index c42ac1c51ad..85b5fc8a356 100644
--- a/Kernel/FileSystem/File.h
+++ b/Kernel/FileSystem/File.h
@@ -6,12 +6,12 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/NonnullRefPtr.h>
 #include <AK/RefCounted.h>
 #include <AK/String.h>
 #include <AK/Types.h>
 #include <AK/Weakable.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Forward.h>
 #include <Kernel/UnixTypes.h>
 #include <Kernel/UserOrKernelBuffer.h>
@@ -78,28 +78,28 @@ public:
     virtual void before_removing() { }
     virtual ~File();
 
-    virtual KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options);
-    virtual KResult close();
+    virtual ErrorOr<NonnullRefPtr<OpenFileDescription>> open(int options);
+    virtual ErrorOr<void> close();
 
     virtual bool can_read(const OpenFileDescription&, size_t) const = 0;
     virtual bool can_write(const OpenFileDescription&, size_t) const = 0;
 
-    virtual KResult attach(OpenFileDescription&);
+    virtual ErrorOr<void> attach(OpenFileDescription&);
     virtual void detach(OpenFileDescription&);
     virtual void did_seek(OpenFileDescription&, off_t) { }
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) = 0;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) = 0;
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg);
-    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
-    virtual KResult stat(::stat&) const { return EBADF; }
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) = 0;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) = 0;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg);
+    virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
+    virtual ErrorOr<void> stat(::stat&) const { return EBADF; }
 
     // Although this might be better described "name" or "description", these terms already have other meanings.
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const = 0;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const = 0;
 
-    virtual KResult truncate(u64) { return EINVAL; }
-    virtual KResult sync() { return EINVAL; }
-    virtual KResult chown(OpenFileDescription&, UserID, GroupID) { return EBADF; }
-    virtual KResult chmod(OpenFileDescription&, mode_t) { return EBADF; }
+    virtual ErrorOr<void> truncate(u64) { return EINVAL; }
+    virtual ErrorOr<void> sync() { return EINVAL; }
+    virtual ErrorOr<void> chown(OpenFileDescription&, UserID, GroupID) { return EBADF; }
+    virtual ErrorOr<void> chmod(OpenFileDescription&, mode_t) { return EBADF; }
 
     virtual StringView class_name() const = 0;
 
diff --git a/Kernel/FileSystem/FileSystem.h b/Kernel/FileSystem/FileSystem.h
index b5e22ef15c4..9222d8e6aae 100644
--- a/Kernel/FileSystem/FileSystem.h
+++ b/Kernel/FileSystem/FileSystem.h
@@ -6,10 +6,10 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/RefCounted.h>
 #include <AK/RefPtr.h>
 #include <AK/StringView.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/InodeIdentifier.h>
 #include <Kernel/Forward.h>
 #include <Kernel/Locking/Mutex.h>
@@ -31,7 +31,7 @@ public:
     static void sync();
     static void lock_all();
 
-    virtual KResult initialize() = 0;
+    virtual ErrorOr<void> initialize() = 0;
     virtual StringView class_name() const = 0;
     virtual Inode& root_inode() = 0;
     virtual bool supports_watchers() const { return false; }
@@ -43,7 +43,7 @@ public:
     virtual unsigned total_inode_count() const { return 0; }
     virtual unsigned free_inode_count() const { return 0; }
 
-    virtual KResult prepare_to_unmount() { return KSuccess; }
+    virtual ErrorOr<void> prepare_to_unmount() { return {}; }
 
     struct DirectoryEntryView {
         DirectoryEntryView(const StringView& name, InodeIdentifier, u8 file_type);
diff --git a/Kernel/FileSystem/ISO9660FileSystem.cpp b/Kernel/FileSystem/ISO9660FileSystem.cpp
index 492433f3d73..b42398719fa 100644
--- a/Kernel/FileSystem/ISO9660FileSystem.cpp
+++ b/Kernel/FileSystem/ISO9660FileSystem.cpp
@@ -46,7 +46,7 @@ public:
     ISO::DirectoryRecordHeader const* operator*() { return m_current_header; }
 
     // Recurses into subdirectories. May fail.
-    KResultOr<bool> next()
+    ErrorOr<bool> next()
     {
         if (done())
             return false;
@@ -148,10 +148,10 @@ public:
     }
 
 private:
-    KResult read_directory_contents()
+    ErrorOr<void> read_directory_contents()
     {
         m_current_directory.entry = TRY(m_fs.directory_entry_for_record({}, m_current_header));
-        return KSuccess;
+        return {};
     }
 
     void get_header()
@@ -171,7 +171,7 @@ private:
     Vector<DirectoryState> m_directory_stack;
 };
 
-KResultOr<NonnullRefPtr<ISO9660FS>> ISO9660FS::try_create(OpenFileDescription& description)
+ErrorOr<NonnullRefPtr<ISO9660FS>> ISO9660FS::try_create(OpenFileDescription& description)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ISO9660FS(description));
 }
@@ -187,12 +187,12 @@ ISO9660FS::~ISO9660FS()
 {
 }
 
-KResult ISO9660FS::initialize()
+ErrorOr<void> ISO9660FS::initialize()
 {
     TRY(BlockBasedFileSystem::initialize());
     TRY(parse_volume_set());
     TRY(create_root_inode());
-    return KSuccess;
+    return {};
 }
 
 Inode& ISO9660FS::root_inode()
@@ -211,7 +211,7 @@ unsigned ISO9660FS::total_inode_count() const
     if (!m_cached_inode_count) {
         auto result = calculate_inode_count();
         if (result.is_error()) {
-            // FIXME: This should be able to return a KResult.
+            // FIXME: This should be able to return a ErrorOr<void>.
             return 0;
         }
     }
@@ -228,7 +228,7 @@ u8 ISO9660FS::internal_file_type_to_directory_entry_type(const DirectoryEntryVie
     return DT_REG;
 }
 
-KResult ISO9660FS::parse_volume_set()
+ErrorOr<void> ISO9660FS::parse_volume_set()
 {
     VERIFY(!m_primary_volume);
 
@@ -278,10 +278,10 @@ all_headers_read:
     }
 
     m_logical_block_size = LittleEndian { m_primary_volume->logical_block_size.little };
-    return KSuccess;
+    return {};
 }
 
-KResult ISO9660FS::create_root_inode()
+ErrorOr<void> ISO9660FS::create_root_inode()
 {
     if (!m_primary_volume) {
         dbgln_if(ISO9660_DEBUG, "Primary volume doesn't exist, can't create root inode");
@@ -289,10 +289,10 @@ KResult ISO9660FS::create_root_inode()
     }
 
     m_root_inode = TRY(ISO9660Inode::try_create_from_directory_record(*this, m_primary_volume->root_directory_record_header, {}));
-    return KSuccess;
+    return {};
 }
 
-KResult ISO9660FS::calculate_inode_count() const
+ErrorOr<void> ISO9660FS::calculate_inode_count() const
 {
     if (!m_primary_volume) {
         dbgln_if(ISO9660_DEBUG, "Primary volume doesn't exist, can't calculate inode count");
@@ -323,13 +323,13 @@ KResult ISO9660FS::calculate_inode_count() const
     }));
 
     m_cached_inode_count = inode_count;
-    return KSuccess;
+    return {};
 }
 
-KResult ISO9660FS::visit_directory_record(ISO::DirectoryRecordHeader const& record, Function<KResultOr<RecursionDecision>(ISO::DirectoryRecordHeader const*)> const& visitor) const
+ErrorOr<void> ISO9660FS::visit_directory_record(ISO::DirectoryRecordHeader const& record, Function<ErrorOr<RecursionDecision>(ISO::DirectoryRecordHeader const*)> const& visitor) const
 {
     if (!has_flag(record.file_flags, ISO::FileFlags::Directory)) {
-        return KSuccess;
+        return {};
     }
 
     ISO9660DirectoryIterator iterator { const_cast<ISO9660FS&>(*this), record };
@@ -342,7 +342,7 @@ KResult ISO9660FS::visit_directory_record(ISO::DirectoryRecordHeader const& reco
             if (!has_moved) {
                 // If next() hasn't moved then we have read through all the
                 // directories, and can exit.
-                return KSuccess;
+                return {};
             }
 
             continue;
@@ -352,20 +352,20 @@ KResult ISO9660FS::visit_directory_record(ISO::DirectoryRecordHeader const& reco
                 if (iterator.skip())
                     break;
                 if (!iterator.go_up())
-                    return KSuccess;
+                    return {};
             }
 
             continue;
         }
         case RecursionDecision::Break:
-            return KSuccess;
+            return {};
         }
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<ISO9660FS::DirectoryEntry>> ISO9660FS::directory_entry_for_record(Badge<ISO9660DirectoryIterator>, ISO::DirectoryRecordHeader const* record)
+ErrorOr<NonnullRefPtr<ISO9660FS::DirectoryEntry>> ISO9660FS::directory_entry_for_record(Badge<ISO9660DirectoryIterator>, ISO::DirectoryRecordHeader const* record)
 {
     u32 extent_location = LittleEndian { record->extent_location.little };
     u32 data_length = LittleEndian { record->data_length.little };
@@ -407,7 +407,7 @@ u32 ISO9660FS::calculate_directory_entry_cache_key(ISO::DirectoryRecordHeader co
     return LittleEndian { record.extent_location.little };
 }
 
-KResultOr<size_t> ISO9660Inode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> ISO9660Inode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     MutexLocker inode_locker(m_inode_lock);
 
@@ -450,7 +450,7 @@ InodeMetadata ISO9660Inode::metadata() const
     return m_metadata;
 }
 
-KResult ISO9660Inode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> visitor) const
+ErrorOr<void> ISO9660Inode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> visitor) const
 {
     Array<u8, max_file_identifier_length> file_identifier_buffer;
 
@@ -469,7 +469,7 @@ KResult ISO9660Inode::traverse_as_directory(Function<bool(FileSystem::DirectoryE
     });
 }
 
-KResultOr<NonnullRefPtr<Inode>> ISO9660Inode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> ISO9660Inode::lookup(StringView name)
 {
     RefPtr<Inode> inode;
     Array<u8, max_file_identifier_length> file_identifier_buffer;
@@ -481,8 +481,8 @@ KResultOr<NonnullRefPtr<Inode>> ISO9660Inode::lookup(StringView name)
             auto maybe_inode = ISO9660Inode::try_create_from_directory_record(fs(), *record, filename);
             if (maybe_inode.is_error()) {
                 // FIXME: The Inode API does not handle allocation failures very
-                //        well... we can't return a KResultOr from here. It
-                //        would be nice if we could return a KResult(Or) from
+                //        well... we can't return a ErrorOr from here. It
+                //        would be nice if we could return a ErrorOr<void>(Or) from
                 //        any place where allocation may happen.
                 dbgln("Could not allocate inode for lookup!");
             } else {
@@ -499,57 +499,57 @@ KResultOr<NonnullRefPtr<Inode>> ISO9660Inode::lookup(StringView name)
     return inode.release_nonnull();
 }
 
-KResult ISO9660Inode::flush_metadata()
+ErrorOr<void> ISO9660Inode::flush_metadata()
 {
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> ISO9660Inode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
+ErrorOr<size_t> ISO9660Inode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     return EROFS;
 }
 
-KResultOr<NonnullRefPtr<Inode>> ISO9660Inode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
+ErrorOr<NonnullRefPtr<Inode>> ISO9660Inode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::add_child(Inode&, const StringView&, mode_t)
+ErrorOr<void> ISO9660Inode::add_child(Inode&, const StringView&, mode_t)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::remove_child(const StringView&)
+ErrorOr<void> ISO9660Inode::remove_child(const StringView&)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::chmod(mode_t)
+ErrorOr<void> ISO9660Inode::chmod(mode_t)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::chown(UserID, GroupID)
+ErrorOr<void> ISO9660Inode::chown(UserID, GroupID)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::truncate(u64)
+ErrorOr<void> ISO9660Inode::truncate(u64)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::set_atime(time_t)
+ErrorOr<void> ISO9660Inode::set_atime(time_t)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::set_ctime(time_t)
+ErrorOr<void> ISO9660Inode::set_ctime(time_t)
 {
     return EROFS;
 }
 
-KResult ISO9660Inode::set_mtime(time_t)
+ErrorOr<void> ISO9660Inode::set_mtime(time_t)
 {
     return EROFS;
 }
@@ -570,7 +570,7 @@ ISO9660Inode::~ISO9660Inode()
 {
 }
 
-KResultOr<NonnullRefPtr<ISO9660Inode>> ISO9660Inode::try_create_from_directory_record(ISO9660FS& fs, ISO::DirectoryRecordHeader const& record, StringView const& name)
+ErrorOr<NonnullRefPtr<ISO9660Inode>> ISO9660Inode::try_create_from_directory_record(ISO9660FS& fs, ISO::DirectoryRecordHeader const& record, StringView const& name)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ISO9660Inode(fs, record, name));
 }
diff --git a/Kernel/FileSystem/ISO9660FileSystem.h b/Kernel/FileSystem/ISO9660FileSystem.h
index 5db938cdd8b..d5789661176 100644
--- a/Kernel/FileSystem/ISO9660FileSystem.h
+++ b/Kernel/FileSystem/ISO9660FileSystem.h
@@ -7,12 +7,12 @@
 #pragma once
 
 #include <AK/EnumBits.h>
+#include <AK/Error.h>
 #include <AK/HashMap.h>
 #include <AK/NonnullRefPtr.h>
 #include <AK/RecursionDecision.h>
 #include <AK/StringView.h>
 #include <AK/Types.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/BlockBasedFileSystem.h>
 #include <Kernel/FileSystem/Inode.h>
 #include <Kernel/KBuffer.h>
@@ -291,7 +291,7 @@ public:
         //       We need it as an OwnPtr to default-construct this struct.
         OwnPtr<KBuffer> blocks;
 
-        static KResultOr<NonnullRefPtr<DirectoryEntry>> try_create(u32 extent, u32 length, OwnPtr<KBuffer> blocks)
+        static ErrorOr<NonnullRefPtr<DirectoryEntry>> try_create(u32 extent, u32 length, OwnPtr<KBuffer> blocks)
         {
             return adopt_nonnull_ref_or_enomem(new (nothrow) DirectoryEntry(extent, length, move(blocks)));
         }
@@ -305,10 +305,10 @@ public:
         }
     };
 
-    static KResultOr<NonnullRefPtr<ISO9660FS>> try_create(OpenFileDescription&);
+    static ErrorOr<NonnullRefPtr<ISO9660FS>> try_create(OpenFileDescription&);
 
     virtual ~ISO9660FS() override;
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
     virtual StringView class_name() const override { return "ISO9660FS"sv; }
     virtual Inode& root_inode() override;
 
@@ -317,18 +317,18 @@ public:
 
     virtual u8 internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const override;
 
-    KResultOr<NonnullRefPtr<DirectoryEntry>> directory_entry_for_record(Badge<ISO9660DirectoryIterator>, ISO::DirectoryRecordHeader const* record);
+    ErrorOr<NonnullRefPtr<DirectoryEntry>> directory_entry_for_record(Badge<ISO9660DirectoryIterator>, ISO::DirectoryRecordHeader const* record);
 
 private:
     ISO9660FS(OpenFileDescription&);
 
-    KResult parse_volume_set();
-    KResult create_root_inode();
-    KResult calculate_inode_count() const;
+    ErrorOr<void> parse_volume_set();
+    ErrorOr<void> create_root_inode();
+    ErrorOr<void> calculate_inode_count() const;
 
     u32 calculate_directory_entry_cache_key(ISO::DirectoryRecordHeader const&);
 
-    KResult visit_directory_record(ISO::DirectoryRecordHeader const& record, Function<KResultOr<RecursionDecision>(ISO::DirectoryRecordHeader const*)> const& visitor) const;
+    ErrorOr<void> visit_directory_record(ISO::DirectoryRecordHeader const& record, Function<ErrorOr<RecursionDecision>(ISO::DirectoryRecordHeader const*)> const& visitor) const;
 
     OwnPtr<ISO::PrimaryVolumeDescriptor> m_primary_volume;
     RefPtr<ISO9660Inode> m_root_inode;
@@ -347,21 +347,21 @@ public:
     ISO9660FS const& fs() const { return static_cast<ISO9660FS const&>(Inode::fs()); }
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
-    virtual KResult flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
-    virtual KResult remove_child(const StringView& name) override;
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
-    virtual KResult truncate(u64) override;
-    virtual KResult set_atime(time_t) override;
-    virtual KResult set_ctime(time_t) override;
-    virtual KResult set_mtime(time_t) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> flush_metadata() override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> add_child(Inode&, const StringView& name, mode_t) override;
+    virtual ErrorOr<void> remove_child(const StringView& name) override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
+    virtual ErrorOr<void> truncate(u64) override;
+    virtual ErrorOr<void> set_atime(time_t) override;
+    virtual ErrorOr<void> set_ctime(time_t) override;
+    virtual ErrorOr<void> set_mtime(time_t) override;
     virtual void one_ref_left() override;
 
 private:
@@ -371,7 +371,7 @@ private:
     static constexpr size_t max_file_identifier_length = 256 - sizeof(ISO::DirectoryRecordHeader);
 
     ISO9660Inode(ISO9660FS&, ISO::DirectoryRecordHeader const& record, StringView const& name);
-    static KResultOr<NonnullRefPtr<ISO9660Inode>> try_create_from_directory_record(ISO9660FS&, ISO::DirectoryRecordHeader const& record, StringView const& name);
+    static ErrorOr<NonnullRefPtr<ISO9660Inode>> try_create_from_directory_record(ISO9660FS&, ISO::DirectoryRecordHeader const& record, StringView const& name);
 
     static InodeIndex get_inode_index(ISO::DirectoryRecordHeader const& record, StringView const& name);
     static StringView get_normalized_filename(ISO::DirectoryRecordHeader const& record, Bytes buffer);
diff --git a/Kernel/FileSystem/Inode.cpp b/Kernel/FileSystem/Inode.cpp
index dd53e593d9f..78a3d7db6bd 100644
--- a/Kernel/FileSystem/Inode.cpp
+++ b/Kernel/FileSystem/Inode.cpp
@@ -52,7 +52,7 @@ void Inode::sync()
     fs().flush_writes();
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(OpenFileDescription* description) const
+ErrorOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(OpenFileDescription* description) const
 {
     auto builder = TRY(KBufferBuilder::try_create());
 
@@ -76,7 +76,7 @@ KResultOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(OpenFileDescription* descri
     return entire_file.release_nonnull();
 }
 
-KResultOr<NonnullRefPtr<Custody>> Inode::resolve_as_link(Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level) const
+ErrorOr<NonnullRefPtr<Custody>> Inode::resolve_as_link(Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level) const
 {
     // The default implementation simply treats the stored
     // contents as a path and resolves that. That is, it
@@ -106,27 +106,27 @@ void Inode::will_be_destroyed()
         (void)flush_metadata();
 }
 
-KResult Inode::set_atime(time_t)
+ErrorOr<void> Inode::set_atime(time_t)
 {
     return ENOTIMPL;
 }
 
-KResult Inode::set_ctime(time_t)
+ErrorOr<void> Inode::set_ctime(time_t)
 {
     return ENOTIMPL;
 }
 
-KResult Inode::set_mtime(time_t)
+ErrorOr<void> Inode::set_mtime(time_t)
 {
     return ENOTIMPL;
 }
 
-KResult Inode::increment_link_count()
+ErrorOr<void> Inode::increment_link_count()
 {
     return ENOTIMPL;
 }
 
-KResult Inode::decrement_link_count()
+ErrorOr<void> Inode::decrement_link_count()
 {
     return ENOTIMPL;
 }
@@ -169,7 +169,7 @@ void Inode::unregister_watcher(Badge<InodeWatcher>, InodeWatcher& watcher)
     m_watchers.remove(&watcher);
 }
 
-KResultOr<NonnullRefPtr<FIFO>> Inode::fifo()
+ErrorOr<NonnullRefPtr<FIFO>> Inode::fifo()
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(metadata().is_fifo());
@@ -178,7 +178,7 @@ KResultOr<NonnullRefPtr<FIFO>> Inode::fifo()
     if (!m_fifo)
         m_fifo = TRY(FIFO::try_create(metadata().uid));
 
-    return *m_fifo;
+    return NonnullRefPtr { *m_fifo };
 }
 
 void Inode::set_metadata_dirty(bool metadata_dirty)
@@ -242,7 +242,7 @@ void Inode::did_delete_self()
     }
 }
 
-KResult Inode::prepare_to_write_data()
+ErrorOr<void> Inode::prepare_to_write_data()
 {
     // FIXME: It's a poor design that filesystems are expected to call this before writing out data.
     //        We should funnel everything through an interface at the VirtualFileSystem layer so this can happen from a single place.
@@ -254,7 +254,7 @@ KResult Inode::prepare_to_write_data()
         dbgln("Inode::prepare_to_write_data(): Stripping SUID/SGID bits from {}", identifier());
         return chmod(metadata.mode & ~(04000 | 02000));
     }
-    return KSuccess;
+    return {};
 }
 
 RefPtr<Memory::SharedInodeVMObject> Inode::shared_vmobject() const
@@ -269,7 +269,7 @@ static inline bool range_overlap(T start1, T len1, T start2, T len2)
     return ((start1 < start2 + len2) || len2 == 0) && ((start2 < start1 + len1) || len1 == 0);
 }
 
-static inline KResult normalize_flock(OpenFileDescription const& description, flock& lock)
+static inline ErrorOr<void> normalize_flock(OpenFileDescription const& description, flock& lock)
 {
     off_t start;
     switch (lock.l_whence) {
@@ -286,10 +286,10 @@ static inline KResult normalize_flock(OpenFileDescription const& description, fl
         return EINVAL;
     }
     lock = { lock.l_type, SEEK_SET, start, lock.l_len, 0 };
-    return KSuccess;
+    return {};
 }
 
-KResult Inode::can_apply_flock(OpenFileDescription const& description, flock const& new_lock) const
+ErrorOr<void> Inode::can_apply_flock(OpenFileDescription const& description, flock const& new_lock) const
 {
     VERIFY(new_lock.l_whence == SEEK_SET);
 
@@ -298,7 +298,7 @@ KResult Inode::can_apply_flock(OpenFileDescription const& description, flock con
     if (new_lock.l_type == F_UNLCK) {
         for (auto& lock : m_flocks) {
             if (&description == lock.owner && lock.start == new_lock.l_start && lock.len == new_lock.l_len)
-                return KSuccess;
+                return {};
         }
         return EINVAL;
     }
@@ -313,10 +313,10 @@ KResult Inode::can_apply_flock(OpenFileDescription const& description, flock con
         if (new_lock.l_type == F_WRLCK)
             return EAGAIN;
     }
-    return KSuccess;
+    return {};
 }
 
-KResult Inode::apply_flock(Process const& process, OpenFileDescription const& description, Userspace<flock const*> input_lock)
+ErrorOr<void> Inode::apply_flock(Process const& process, OpenFileDescription const& description, Userspace<flock const*> input_lock)
 {
     flock new_lock = {};
     TRY(copy_from_user(&new_lock, input_lock));
@@ -330,17 +330,17 @@ KResult Inode::apply_flock(Process const& process, OpenFileDescription const& de
         for (size_t i = 0; i < m_flocks.size(); ++i) {
             if (&description == m_flocks[i].owner && m_flocks[i].start == new_lock.l_start && m_flocks[i].len == new_lock.l_len) {
                 m_flocks.remove(i);
-                return KSuccess;
+                return {};
             }
         }
         return EINVAL;
     }
 
     m_flocks.append(Flock { new_lock.l_start, new_lock.l_len, &description, process.pid().value(), new_lock.l_type });
-    return KSuccess;
+    return {};
 }
 
-KResult Inode::get_flock(OpenFileDescription const& description, Userspace<flock*> reference_lock) const
+ErrorOr<void> Inode::get_flock(OpenFileDescription const& description, Userspace<flock*> reference_lock) const
 {
     flock lookup = {};
     TRY(copy_from_user(&lookup, reference_lock));
diff --git a/Kernel/FileSystem/Inode.h b/Kernel/FileSystem/Inode.h
index eddb3030c1b..e0ede5b0925 100644
--- a/Kernel/FileSystem/Inode.h
+++ b/Kernel/FileSystem/Inode.h
@@ -7,12 +7,12 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/Function.h>
 #include <AK/HashTable.h>
 #include <AK/IntrusiveList.h>
 #include <AK/String.h>
 #include <AK/WeakPtr.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/FIFO.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/InodeIdentifier.h>
@@ -47,24 +47,24 @@ public:
     InodeIdentifier identifier() const { return { fsid(), index() }; }
     virtual InodeMetadata metadata() const = 0;
 
-    KResultOr<NonnullOwnPtr<KBuffer>> read_entire(OpenFileDescription* = nullptr) const;
+    ErrorOr<NonnullOwnPtr<KBuffer>> read_entire(OpenFileDescription* = nullptr) const;
 
-    virtual KResult attach(OpenFileDescription&) { return KSuccess; }
+    virtual ErrorOr<void> attach(OpenFileDescription&) { return {}; }
     virtual void detach(OpenFileDescription&) { }
     virtual void did_seek(OpenFileDescription&, off_t) { }
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const = 0;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const = 0;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) = 0;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) = 0;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) = 0;
-    virtual KResult add_child(Inode&, const StringView& name, mode_t) = 0;
-    virtual KResult remove_child(const StringView& name) = 0;
-    virtual KResult chmod(mode_t) = 0;
-    virtual KResult chown(UserID, GroupID) = 0;
-    virtual KResult truncate(u64) { return KSuccess; }
-    virtual KResultOr<NonnullRefPtr<Custody>> resolve_as_link(Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level) const;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const = 0;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const = 0;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) = 0;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) = 0;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) = 0;
+    virtual ErrorOr<void> add_child(Inode&, const StringView& name, mode_t) = 0;
+    virtual ErrorOr<void> remove_child(const StringView& name) = 0;
+    virtual ErrorOr<void> chmod(mode_t) = 0;
+    virtual ErrorOr<void> chown(UserID, GroupID) = 0;
+    virtual ErrorOr<void> truncate(u64) { return {}; }
+    virtual ErrorOr<NonnullRefPtr<Custody>> resolve_as_link(Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level) const;
 
-    virtual KResultOr<int> get_block_address(int) { return ENOTSUP; }
+    virtual ErrorOr<int> get_block_address(int) { return ENOTSUP; }
 
     LocalSocket* socket() { return m_socket.ptr(); }
     const LocalSocket* socket() const { return m_socket.ptr(); }
@@ -75,13 +75,13 @@ public:
 
     bool is_metadata_dirty() const { return m_metadata_dirty; }
 
-    virtual KResult set_atime(time_t);
-    virtual KResult set_ctime(time_t);
-    virtual KResult set_mtime(time_t);
-    virtual KResult increment_link_count();
-    virtual KResult decrement_link_count();
+    virtual ErrorOr<void> set_atime(time_t);
+    virtual ErrorOr<void> set_ctime(time_t);
+    virtual ErrorOr<void> set_mtime(time_t);
+    virtual ErrorOr<void> increment_link_count();
+    virtual ErrorOr<void> decrement_link_count();
 
-    virtual KResult flush_metadata() = 0;
+    virtual ErrorOr<void> flush_metadata() = 0;
 
     void will_be_destroyed();
 
@@ -96,17 +96,17 @@ public:
     void register_watcher(Badge<InodeWatcher>, InodeWatcher&);
     void unregister_watcher(Badge<InodeWatcher>, InodeWatcher&);
 
-    KResultOr<NonnullRefPtr<FIFO>> fifo();
+    ErrorOr<NonnullRefPtr<FIFO>> fifo();
 
-    KResult can_apply_flock(OpenFileDescription const&, flock const&) const;
-    KResult apply_flock(Process const&, OpenFileDescription const&, Userspace<flock const*>);
-    KResult get_flock(OpenFileDescription const&, Userspace<flock*>) const;
+    ErrorOr<void> can_apply_flock(OpenFileDescription const&, flock const&) const;
+    ErrorOr<void> apply_flock(Process const&, OpenFileDescription const&, Userspace<flock const*>);
+    ErrorOr<void> get_flock(OpenFileDescription const&, Userspace<flock*>) const;
     void remove_flocks_for_description(OpenFileDescription const&);
 
 protected:
     Inode(FileSystem&, InodeIndex);
     void set_metadata_dirty(bool);
-    KResult prepare_to_write_data();
+    ErrorOr<void> prepare_to_write_data();
 
     void did_add_child(InodeIdentifier const& child_id, String const& name);
     void did_remove_child(InodeIdentifier const& child_id, String const& name);
diff --git a/Kernel/FileSystem/InodeFile.cpp b/Kernel/FileSystem/InodeFile.cpp
index 009de243c7c..f72f7ffd12d 100644
--- a/Kernel/FileSystem/InodeFile.cpp
+++ b/Kernel/FileSystem/InodeFile.cpp
@@ -26,7 +26,7 @@ InodeFile::~InodeFile()
 {
 }
 
-KResultOr<size_t> InodeFile::read(OpenFileDescription& description, u64 offset, UserOrKernelBuffer& buffer, size_t count)
+ErrorOr<size_t> InodeFile::read(OpenFileDescription& description, u64 offset, UserOrKernelBuffer& buffer, size_t count)
 {
     if (Checked<off_t>::addition_would_overflow(offset, count))
         return EOVERFLOW;
@@ -39,7 +39,7 @@ KResultOr<size_t> InodeFile::read(OpenFileDescription& description, u64 offset,
     return nread;
 }
 
-KResultOr<size_t> InodeFile::write(OpenFileDescription& description, u64 offset, const UserOrKernelBuffer& data, size_t count)
+ErrorOr<size_t> InodeFile::write(OpenFileDescription& description, u64 offset, const UserOrKernelBuffer& data, size_t count)
 {
     if (Checked<off_t>::addition_would_overflow(offset, count))
         return EOVERFLOW;
@@ -50,12 +50,12 @@ KResultOr<size_t> InodeFile::write(OpenFileDescription& description, u64 offset,
         Thread::current()->did_file_write(nwritten);
         evaluate_block_conditions();
         if (mtime_result.is_error())
-            return mtime_result;
+            return mtime_result.release_error();
     }
     return nwritten;
 }
 
-KResult InodeFile::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
+ErrorOr<void> InodeFile::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case FIBMAP: {
@@ -81,7 +81,7 @@ KResult InodeFile::ioctl(OpenFileDescription& description, unsigned request, Use
     }
 }
 
-KResultOr<Memory::Region*> InodeFile::mmap(Process& process, OpenFileDescription& description, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+ErrorOr<Memory::Region*> InodeFile::mmap(Process& process, OpenFileDescription& description, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     // FIXME: If PROT_EXEC, check that the underlying file system isn't mounted noexec.
     RefPtr<Memory::InodeVMObject> vmobject;
@@ -93,33 +93,33 @@ KResultOr<Memory::Region*> InodeFile::mmap(Process& process, OpenFileDescription
     return process.address_space().allocate_region_with_vmobject(range, vmobject.release_nonnull(), offset, path->view(), prot, shared);
 }
 
-KResultOr<NonnullOwnPtr<KString>> InodeFile::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> InodeFile::pseudo_path(const OpenFileDescription&) const
 {
     // If it has an inode, then it has a path, and therefore the caller should have been able to get a custody at some point.
     VERIFY_NOT_REACHED();
 }
 
-KResult InodeFile::truncate(u64 size)
+ErrorOr<void> InodeFile::truncate(u64 size)
 {
     TRY(m_inode->truncate(size));
     TRY(m_inode->set_mtime(kgettimeofday().to_truncated_seconds()));
-    return KSuccess;
+    return {};
 }
 
-KResult InodeFile::sync()
+ErrorOr<void> InodeFile::sync()
 {
     m_inode->sync();
-    return KSuccess;
+    return {};
 }
 
-KResult InodeFile::chown(OpenFileDescription& description, UserID uid, GroupID gid)
+ErrorOr<void> InodeFile::chown(OpenFileDescription& description, UserID uid, GroupID gid)
 {
     VERIFY(description.inode() == m_inode);
     VERIFY(description.custody());
     return VirtualFileSystem::the().chown(*description.custody(), uid, gid);
 }
 
-KResult InodeFile::chmod(OpenFileDescription& description, mode_t mode)
+ErrorOr<void> InodeFile::chmod(OpenFileDescription& description, mode_t mode)
 {
     VERIFY(description.inode() == m_inode);
     VERIFY(description.custody());
diff --git a/Kernel/FileSystem/InodeFile.h b/Kernel/FileSystem/InodeFile.h
index ec220bbf991..1701d41c065 100644
--- a/Kernel/FileSystem/InodeFile.h
+++ b/Kernel/FileSystem/InodeFile.h
@@ -14,7 +14,7 @@ class Inode;
 
 class InodeFile final : public File {
 public:
-    static KResultOr<NonnullRefPtr<InodeFile>> create(NonnullRefPtr<Inode>&& inode)
+    static ErrorOr<NonnullRefPtr<InodeFile>> create(NonnullRefPtr<Inode>&& inode)
     {
         auto file = adopt_ref_if_nonnull(new (nothrow) InodeFile(move(inode)));
         if (!file)
@@ -30,18 +30,18 @@ public:
     virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
-    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
-    virtual KResult stat(::stat& buffer) const override { return inode().metadata().stat(buffer); }
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual ErrorOr<void> stat(::stat& buffer) const override { return inode().metadata().stat(buffer); }
 
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
 
-    virtual KResult truncate(u64) override;
-    virtual KResult sync() override;
-    virtual KResult chown(OpenFileDescription&, UserID, GroupID) override;
-    virtual KResult chmod(OpenFileDescription&, mode_t) override;
+    virtual ErrorOr<void> truncate(u64) override;
+    virtual ErrorOr<void> sync() override;
+    virtual ErrorOr<void> chown(OpenFileDescription&, UserID, GroupID) override;
+    virtual ErrorOr<void> chmod(OpenFileDescription&, mode_t) override;
 
     virtual StringView class_name() const override { return "InodeFile"sv; }
 
diff --git a/Kernel/FileSystem/InodeMetadata.h b/Kernel/FileSystem/InodeMetadata.h
index ba61a762348..8c14562ae8d 100644
--- a/Kernel/FileSystem/InodeMetadata.h
+++ b/Kernel/FileSystem/InodeMetadata.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/Span.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/InodeIdentifier.h>
 #include <Kernel/Forward.h>
 #include <Kernel/UnixTypes.h>
@@ -86,7 +86,7 @@ struct InodeMetadata {
     bool is_setuid() const { return Kernel::is_setuid(mode); }
     bool is_setgid() const { return Kernel::is_setgid(mode); }
 
-    KResult stat(stat& buffer) const
+    ErrorOr<void> stat(stat& buffer) const
     {
         if (!is_valid())
             return EIO;
@@ -106,7 +106,7 @@ struct InodeMetadata {
         buffer.st_mtim.tv_nsec = 0;
         buffer.st_ctim.tv_sec = ctime;
         buffer.st_ctim.tv_nsec = 0;
-        return KSuccess;
+        return {};
     }
 
     InodeIdentifier inode;
diff --git a/Kernel/FileSystem/InodeWatcher.cpp b/Kernel/FileSystem/InodeWatcher.cpp
index bd750c53651..69a9af80163 100644
--- a/Kernel/FileSystem/InodeWatcher.cpp
+++ b/Kernel/FileSystem/InodeWatcher.cpp
@@ -12,7 +12,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<InodeWatcher>> InodeWatcher::try_create()
+ErrorOr<NonnullRefPtr<InodeWatcher>> InodeWatcher::try_create()
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) InodeWatcher);
 }
@@ -28,7 +28,7 @@ bool InodeWatcher::can_read(const OpenFileDescription&, size_t) const
     return !m_queue.is_empty();
 }
 
-KResultOr<size_t> InodeWatcher::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t buffer_size)
+ErrorOr<size_t> InodeWatcher::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t buffer_size)
 {
     MutexLocker locker(m_lock);
     if (m_queue.is_empty())
@@ -67,7 +67,7 @@ KResultOr<size_t> InodeWatcher::read(OpenFileDescription&, u64, UserOrKernelBuff
     return result;
 }
 
-KResult InodeWatcher::close()
+ErrorOr<void> InodeWatcher::close()
 {
     MutexLocker locker(m_lock);
 
@@ -78,10 +78,10 @@ KResult InodeWatcher::close()
 
     m_wd_to_watches.clear();
     m_inode_to_watches.clear();
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullOwnPtr<KString>> InodeWatcher::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> InodeWatcher::pseudo_path(const OpenFileDescription&) const
 {
     return KString::try_create(String::formatted("InodeWatcher:({})", m_wd_to_watches.size()));
 }
@@ -102,7 +102,7 @@ void InodeWatcher::notify_inode_event(Badge<Inode>, InodeIdentifier inode_id, In
     evaluate_block_conditions();
 }
 
-KResultOr<int> InodeWatcher::register_inode(Inode& inode, unsigned event_mask)
+ErrorOr<int> InodeWatcher::register_inode(Inode& inode, unsigned event_mask)
 {
     MutexLocker locker(m_lock);
 
@@ -118,11 +118,8 @@ KResultOr<int> InodeWatcher::register_inode(Inode& inode, unsigned event_mask)
             m_wd_counter = 1;
     } while (m_wd_to_watches.find(wd) != m_wd_to_watches.end());
 
-    auto description_or_error = WatchDescription::create(wd, inode, event_mask);
-    if (description_or_error.is_error())
-        return description_or_error.error();
+    auto description = TRY(WatchDescription::create(wd, inode, event_mask));
 
-    auto description = description_or_error.release_value();
     m_inode_to_watches.set(inode.identifier(), description.ptr());
     m_wd_to_watches.set(wd, move(description));
 
@@ -130,7 +127,7 @@ KResultOr<int> InodeWatcher::register_inode(Inode& inode, unsigned event_mask)
     return wd;
 }
 
-KResult InodeWatcher::unregister_by_wd(int wd)
+ErrorOr<void> InodeWatcher::unregister_by_wd(int wd)
 {
     MutexLocker locker(m_lock);
 
@@ -144,7 +141,7 @@ KResult InodeWatcher::unregister_by_wd(int wd)
     m_inode_to_watches.remove(inode.identifier());
     m_wd_to_watches.remove(it);
 
-    return KSuccess;
+    return {};
 }
 
 void InodeWatcher::unregister_by_inode(Badge<Inode>, InodeIdentifier identifier)
diff --git a/Kernel/FileSystem/InodeWatcher.h b/Kernel/FileSystem/InodeWatcher.h
index 99840da740d..9c3bd0a8099 100644
--- a/Kernel/FileSystem/InodeWatcher.h
+++ b/Kernel/FileSystem/InodeWatcher.h
@@ -24,7 +24,7 @@ struct WatchDescription {
     Inode& inode;
     unsigned event_mask;
 
-    static KResultOr<NonnullOwnPtr<WatchDescription>> create(int wd, Inode& inode, unsigned event_mask)
+    static ErrorOr<NonnullOwnPtr<WatchDescription>> create(int wd, Inode& inode, unsigned event_mask)
     {
         return adopt_nonnull_own_or_enomem(new (nothrow) WatchDescription(wd, inode, event_mask));
     }
@@ -40,24 +40,24 @@ private:
 
 class InodeWatcher final : public File {
 public:
-    static KResultOr<NonnullRefPtr<InodeWatcher>> try_create();
+    static ErrorOr<NonnullRefPtr<InodeWatcher>> try_create();
     virtual ~InodeWatcher() override;
 
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     // Can't write to an inode watcher.
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EIO; }
-    virtual KResult close() override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EIO; }
+    virtual ErrorOr<void> close() override;
 
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
     virtual StringView class_name() const override { return "InodeWatcher"sv; };
     virtual bool is_inode_watcher() const override { return true; }
 
     void notify_inode_event(Badge<Inode>, InodeIdentifier, InodeWatcherEvent::Type, String const& name = {});
 
-    KResultOr<int> register_inode(Inode&, unsigned event_mask);
-    KResult unregister_by_wd(int);
+    ErrorOr<int> register_inode(Inode&, unsigned event_mask);
+    ErrorOr<void> unregister_by_wd(int);
     void unregister_by_inode(Badge<Inode>, InodeIdentifier);
 
 private:
diff --git a/Kernel/FileSystem/OpenFileDescription.cpp b/Kernel/FileSystem/OpenFileDescription.cpp
index 327d0d37e09..a408e085e52 100644
--- a/Kernel/FileSystem/OpenFileDescription.cpp
+++ b/Kernel/FileSystem/OpenFileDescription.cpp
@@ -24,7 +24,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> OpenFileDescription::try_create(Custody& custody)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> OpenFileDescription::try_create(Custody& custody)
 {
     auto inode_file = TRY(InodeFile::create(custody.inode()));
     auto description = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) OpenFileDescription(move(inode_file))));
@@ -34,7 +34,7 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> OpenFileDescription::try_create(Cu
     return description;
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> OpenFileDescription::try_create(File& file)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> OpenFileDescription::try_create(File& file)
 {
     auto description = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) OpenFileDescription(file)));
     TRY(description->attach());
@@ -64,7 +64,7 @@ OpenFileDescription::~OpenFileDescription()
         m_inode->remove_flocks_for_description(*this);
 }
 
-KResult OpenFileDescription::attach()
+ErrorOr<void> OpenFileDescription::attach()
 {
     if (m_inode)
         TRY(m_inode->attach(*this));
@@ -97,7 +97,7 @@ Thread::FileBlocker::BlockFlags OpenFileDescription::should_unblock(Thread::File
     return unblock_flags;
 }
 
-KResult OpenFileDescription::stat(::stat& buffer)
+ErrorOr<void> OpenFileDescription::stat(::stat& buffer)
 {
     MutexLocker locker(m_lock);
     // FIXME: This is due to the Device class not overriding File::stat().
@@ -106,7 +106,7 @@ KResult OpenFileDescription::stat(::stat& buffer)
     return m_file->stat(buffer);
 }
 
-KResultOr<off_t> OpenFileDescription::seek(off_t offset, int whence)
+ErrorOr<off_t> OpenFileDescription::seek(off_t offset, int whence)
 {
     MutexLocker locker(m_lock);
     if (!m_file->is_seekable())
@@ -147,21 +147,21 @@ KResultOr<off_t> OpenFileDescription::seek(off_t offset, int whence)
     return m_current_offset;
 }
 
-KResultOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, u64 offset, size_t count)
+ErrorOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, u64 offset, size_t count)
 {
     if (Checked<u64>::addition_would_overflow(offset, count))
         return EOVERFLOW;
     return m_file->read(*this, offset, buffer, count);
 }
 
-KResultOr<size_t> OpenFileDescription::write(u64 offset, UserOrKernelBuffer const& data, size_t data_size)
+ErrorOr<size_t> OpenFileDescription::write(u64 offset, UserOrKernelBuffer const& data, size_t data_size)
 {
     if (Checked<u64>::addition_would_overflow(offset, data_size))
         return EOVERFLOW;
     return m_file->write(*this, offset, data, data_size);
 }
 
-KResultOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, size_t count)
+ErrorOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, size_t count)
 {
     MutexLocker locker(m_lock);
     if (Checked<off_t>::addition_would_overflow(m_current_offset, count))
@@ -173,7 +173,7 @@ KResultOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, size_t c
     return nread;
 }
 
-KResultOr<size_t> OpenFileDescription::write(const UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> OpenFileDescription::write(const UserOrKernelBuffer& data, size_t size)
 {
     MutexLocker locker(m_lock);
     if (Checked<off_t>::addition_would_overflow(m_current_offset, size))
@@ -195,7 +195,7 @@ bool OpenFileDescription::can_read() const
     return m_file->can_read(*this, offset());
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> OpenFileDescription::read_entire_file()
+ErrorOr<NonnullOwnPtr<KBuffer>> OpenFileDescription::read_entire_file()
 {
     // HACK ALERT: (This entire function)
     VERIFY(m_file->is_inode());
@@ -203,7 +203,7 @@ KResultOr<NonnullOwnPtr<KBuffer>> OpenFileDescription::read_entire_file()
     return m_inode->read_entire(this);
 }
 
-KResultOr<size_t> OpenFileDescription::get_dir_entries(UserOrKernelBuffer& output_buffer, size_t size)
+ErrorOr<size_t> OpenFileDescription::get_dir_entries(UserOrKernelBuffer& output_buffer, size_t size)
 {
     MutexLocker locker(m_lock, Mutex::Mode::Shared);
     if (!is_directory())
@@ -214,7 +214,7 @@ KResultOr<size_t> OpenFileDescription::get_dir_entries(UserOrKernelBuffer& outpu
         return EIO;
 
     size_t remaining = size;
-    KResult error = KSuccess;
+    ErrorOr<void> error;
     u8 stack_buffer[PAGE_SIZE];
     Bytes temp_buffer(stack_buffer, sizeof(stack_buffer));
     OutputMemoryStream stream { temp_buffer };
@@ -238,7 +238,7 @@ KResultOr<size_t> OpenFileDescription::get_dir_entries(UserOrKernelBuffer& outpu
         return true;
     };
 
-    KResult result = VirtualFileSystem::the().traverse_directory_inode(*m_inode, [&flush_stream_to_output_buffer, &stream, this](auto& entry) {
+    ErrorOr<void> result = VirtualFileSystem::the().traverse_directory_inode(*m_inode, [&flush_stream_to_output_buffer, &stream, this](auto& entry) {
         size_t serialized_size = sizeof(ino_t) + sizeof(u8) + sizeof(size_t) + sizeof(char) * entry.name.length();
         if (serialized_size > stream.remaining()) {
             if (!flush_stream_to_output_buffer()) {
@@ -257,12 +257,12 @@ KResultOr<size_t> OpenFileDescription::get_dir_entries(UserOrKernelBuffer& outpu
         // We should only return EFAULT when the userspace buffer is too small,
         // so that userspace can reliably use it as a signal to increase its
         // buffer size.
-        VERIFY(result != EFAULT);
-        return result;
+        VERIFY(result.error().code() != EFAULT);
+        return result.release_error();
     }
 
     if (error.is_error())
-        return error;
+        return error.release_error();
     return size - remaining;
 }
 
@@ -342,21 +342,21 @@ MasterPTY* OpenFileDescription::master_pty()
     return static_cast<MasterPTY*>(m_file.ptr());
 }
 
-KResult OpenFileDescription::close()
+ErrorOr<void> OpenFileDescription::close()
 {
     if (m_file->attach_count() > 0)
-        return KSuccess;
+        return {};
     return m_file->close();
 }
 
-KResultOr<NonnullOwnPtr<KString>> OpenFileDescription::original_absolute_path() const
+ErrorOr<NonnullOwnPtr<KString>> OpenFileDescription::original_absolute_path() const
 {
     if (!m_custody)
         return ENOENT;
     return m_custody->try_serialize_absolute_path();
 }
 
-KResultOr<NonnullOwnPtr<KString>> OpenFileDescription::pseudo_path() const
+ErrorOr<NonnullOwnPtr<KString>> OpenFileDescription::pseudo_path() const
 {
     if (m_custody)
         return m_custody->try_serialize_absolute_path();
@@ -370,19 +370,19 @@ InodeMetadata OpenFileDescription::metadata() const
     return {};
 }
 
-KResultOr<Memory::Region*> OpenFileDescription::mmap(Process& process, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+ErrorOr<Memory::Region*> OpenFileDescription::mmap(Process& process, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     MutexLocker locker(m_lock);
     return m_file->mmap(process, *this, range, offset, prot, shared);
 }
 
-KResult OpenFileDescription::truncate(u64 length)
+ErrorOr<void> OpenFileDescription::truncate(u64 length)
 {
     MutexLocker locker(m_lock);
     return m_file->truncate(length);
 }
 
-KResult OpenFileDescription::sync()
+ErrorOr<void> OpenFileDescription::sync()
 {
     MutexLocker locker(m_lock);
     return m_file->sync();
@@ -428,13 +428,13 @@ void OpenFileDescription::set_file_flags(u32 flags)
     m_file_flags = flags;
 }
 
-KResult OpenFileDescription::chmod(mode_t mode)
+ErrorOr<void> OpenFileDescription::chmod(mode_t mode)
 {
     MutexLocker locker(m_lock);
     return m_file->chmod(*this, mode);
 }
 
-KResult OpenFileDescription::chown(UserID uid, GroupID gid)
+ErrorOr<void> OpenFileDescription::chown(UserID uid, GroupID gid)
 {
     MutexLocker locker(m_lock);
     return m_file->chown(*this, uid, gid);
@@ -445,7 +445,7 @@ FileBlockerSet& OpenFileDescription::blocker_set()
     return m_file->blocker_set();
 }
 
-KResult OpenFileDescription::apply_flock(Process const& process, Userspace<flock const*> lock)
+ErrorOr<void> OpenFileDescription::apply_flock(Process const& process, Userspace<flock const*> lock)
 {
     if (!m_inode)
         return EBADF;
@@ -453,7 +453,7 @@ KResult OpenFileDescription::apply_flock(Process const& process, Userspace<flock
     return m_inode->apply_flock(process, *this, lock);
 }
 
-KResult OpenFileDescription::get_flock(Userspace<flock*> lock) const
+ErrorOr<void> OpenFileDescription::get_flock(Userspace<flock*> lock) const
 {
     if (!m_inode)
         return EBADF;
diff --git a/Kernel/FileSystem/OpenFileDescription.h b/Kernel/FileSystem/OpenFileDescription.h
index 72ec1534397..47247d50a0a 100644
--- a/Kernel/FileSystem/OpenFileDescription.h
+++ b/Kernel/FileSystem/OpenFileDescription.h
@@ -26,8 +26,8 @@ public:
 class OpenFileDescription : public RefCounted<OpenFileDescription> {
     MAKE_SLAB_ALLOCATED(OpenFileDescription)
 public:
-    static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create(Custody&);
-    static KResultOr<NonnullRefPtr<OpenFileDescription>> try_create(File&);
+    static ErrorOr<NonnullRefPtr<OpenFileDescription>> try_create(Custody&);
+    static ErrorOr<NonnullRefPtr<OpenFileDescription>> try_create(File&);
     ~OpenFileDescription();
 
     Thread::FileBlocker::BlockFlags should_unblock(Thread::FileBlocker::BlockFlags) const;
@@ -44,28 +44,28 @@ public:
         set_writable(options & O_WRONLY);
     }
 
-    KResult close();
+    ErrorOr<void> close();
 
-    KResultOr<off_t> seek(off_t, int whence);
-    KResultOr<size_t> read(UserOrKernelBuffer&, size_t);
-    KResultOr<size_t> write(const UserOrKernelBuffer& data, size_t);
-    KResult stat(::stat&);
+    ErrorOr<off_t> seek(off_t, int whence);
+    ErrorOr<size_t> read(UserOrKernelBuffer&, size_t);
+    ErrorOr<size_t> write(const UserOrKernelBuffer& data, size_t);
+    ErrorOr<void> stat(::stat&);
 
     // NOTE: These ignore the current offset of this file description.
-    KResultOr<size_t> read(UserOrKernelBuffer&, u64 offset, size_t);
-    KResultOr<size_t> write(u64 offset, UserOrKernelBuffer const&, size_t);
+    ErrorOr<size_t> read(UserOrKernelBuffer&, u64 offset, size_t);
+    ErrorOr<size_t> write(u64 offset, UserOrKernelBuffer const&, size_t);
 
-    KResult chmod(mode_t);
+    ErrorOr<void> chmod(mode_t);
 
     bool can_read() const;
     bool can_write() const;
 
-    KResultOr<size_t> get_dir_entries(UserOrKernelBuffer& buffer, size_t);
+    ErrorOr<size_t> get_dir_entries(UserOrKernelBuffer& buffer, size_t);
 
-    KResultOr<NonnullOwnPtr<KBuffer>> read_entire_file();
+    ErrorOr<NonnullOwnPtr<KBuffer>> read_entire_file();
 
-    KResultOr<NonnullOwnPtr<KString>> original_absolute_path() const;
-    KResultOr<NonnullOwnPtr<KString>> pseudo_path() const;
+    ErrorOr<NonnullOwnPtr<KString>> original_absolute_path() const;
+    ErrorOr<NonnullOwnPtr<KString>> pseudo_path() const;
 
     bool is_direct() const { return m_direct; }
 
@@ -97,7 +97,7 @@ public:
     Custody* custody() { return m_custody.ptr(); }
     const Custody* custody() const { return m_custody.ptr(); }
 
-    KResultOr<Memory::Region*> mmap(Process&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
+    ErrorOr<Memory::Region*> mmap(Process&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
 
     bool is_blocking() const { return m_is_blocking; }
     void set_blocking(bool b) { m_is_blocking = b; }
@@ -121,23 +121,23 @@ public:
     void set_original_inode(Badge<VirtualFileSystem>, NonnullRefPtr<Inode>&& inode) { m_inode = move(inode); }
     void set_original_custody(Badge<VirtualFileSystem>, Custody& custody);
 
-    KResult truncate(u64);
-    KResult sync();
+    ErrorOr<void> truncate(u64);
+    ErrorOr<void> sync();
 
     off_t offset() const { return m_current_offset; }
 
-    KResult chown(UserID, GroupID);
+    ErrorOr<void> chown(UserID, GroupID);
 
     FileBlockerSet& blocker_set();
 
-    KResult apply_flock(Process const&, Userspace<flock const*>);
-    KResult get_flock(Userspace<flock*>) const;
+    ErrorOr<void> apply_flock(Process const&, Userspace<flock const*>);
+    ErrorOr<void> get_flock(Userspace<flock*>) const;
 
 private:
     friend class VirtualFileSystem;
     explicit OpenFileDescription(File&);
 
-    KResult attach();
+    ErrorOr<void> attach();
 
     void evaluate_block_conditions()
     {
diff --git a/Kernel/FileSystem/Plan9FileSystem.cpp b/Kernel/FileSystem/Plan9FileSystem.cpp
index 3ad1158577e..95439a93569 100644
--- a/Kernel/FileSystem/Plan9FileSystem.cpp
+++ b/Kernel/FileSystem/Plan9FileSystem.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<Plan9FS>> Plan9FS::try_create(OpenFileDescription& file_description)
+ErrorOr<NonnullRefPtr<Plan9FS>> Plan9FS::try_create(OpenFileDescription& file_description)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) Plan9FS(file_description));
 }
@@ -196,7 +196,7 @@ private:
     bool m_have_been_built { false };
 };
 
-KResult Plan9FS::initialize()
+ErrorOr<void> Plan9FS::initialize()
 {
     ensure_thread();
 
@@ -225,7 +225,7 @@ KResult Plan9FS::initialize()
 
     TRY(post_message_and_wait_for_a_reply(attach_message));
     m_root_inode = TRY(Plan9FSInode::try_create(*this, root_fid));
-    return KSuccess;
+    return {};
 }
 
 Plan9FS::ProtocolVersion Plan9FS::parse_protocol_version(const StringView& s) const
@@ -489,7 +489,7 @@ bool Plan9FS::is_complete(const ReceiveCompletion& completion)
     return true;
 }
 
-KResult Plan9FS::post_message(Message& message, RefPtr<ReceiveCompletion> completion)
+ErrorOr<void> Plan9FS::post_message(Message& message, RefPtr<ReceiveCompletion> completion)
 {
     auto& buffer = message.build();
     const u8* data = buffer.data();
@@ -521,10 +521,10 @@ KResult Plan9FS::post_message(Message& message, RefPtr<ReceiveCompletion> comple
         size -= nwritten;
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResult Plan9FS::do_read(u8* data, size_t size)
+ErrorOr<void> Plan9FS::do_read(u8* data, size_t size)
 {
     auto& description = file_description();
     while (size > 0) {
@@ -540,10 +540,10 @@ KResult Plan9FS::do_read(u8* data, size_t size)
         data += nread;
         size -= nread;
     }
-    return KSuccess;
+    return {};
 }
 
-KResult Plan9FS::read_and_dispatch_one_message()
+ErrorOr<void> Plan9FS::read_and_dispatch_one_message()
 {
     struct [[gnu::packed]] Header {
         u32 size;
@@ -564,7 +564,7 @@ KResult Plan9FS::read_and_dispatch_one_message()
     if (optional_completion.has_value()) {
         auto completion = optional_completion.value();
         SpinlockLocker lock(completion->lock);
-        completion->result = KSuccess;
+        completion->result = {};
         completion->message = adopt_own_if_nonnull(new (nothrow) Message { move(buffer) });
         completion->completed = true;
 
@@ -574,15 +574,15 @@ KResult Plan9FS::read_and_dispatch_one_message()
         dbgln("Received a 9p message of type {} with an unexpected tag {}, dropping", header.type, header.tag);
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResult Plan9FS::post_message_and_explicitly_ignore_reply(Message& message)
+ErrorOr<void> Plan9FS::post_message_and_explicitly_ignore_reply(Message& message)
 {
     return post_message(message, {});
 }
 
-KResult Plan9FS::post_message_and_wait_for_a_reply(Message& message)
+ErrorOr<void> Plan9FS::post_message_and_wait_for_a_reply(Message& message)
 {
     auto request_type = message.type();
     auto tag = message.tag();
@@ -602,7 +602,7 @@ KResult Plan9FS::post_message_and_wait_for_a_reply(Message& message)
         // Contains a numerical Linux errno; hopefully our errno numbers match.
         u32 error_code;
         message >> error_code;
-        return KResult((ErrnoCode)error_code);
+        return Error::from_errno((ErrnoCode)error_code);
     } else if (reply_type == Message::Type::Rerror) {
         // Contains an error message. We could attempt to parse it, but for now
         // we simply return EIO instead. In 9P200.u, it can also contain a
@@ -617,7 +617,7 @@ KResult Plan9FS::post_message_and_wait_for_a_reply(Message& message)
         dbgln("Plan9FS: Received unexpected message type {} in response to {}", (u8)reply_type, (u8)request_type);
         return EIO;
     } else {
-        return KSuccess;
+        return {};
     }
 }
 
@@ -668,7 +668,7 @@ Plan9FSInode::Plan9FSInode(Plan9FS& fs, u32 fid)
 {
 }
 
-KResultOr<NonnullRefPtr<Plan9FSInode>> Plan9FSInode::try_create(Plan9FS& fs, u32 fid)
+ErrorOr<NonnullRefPtr<Plan9FSInode>> Plan9FSInode::try_create(Plan9FS& fs, u32 fid)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) Plan9FSInode(fs, fid));
 }
@@ -681,7 +681,7 @@ Plan9FSInode::~Plan9FSInode()
     [[maybe_unused]] auto rc = fs().post_message_and_explicitly_ignore_reply(clunk_request);
 }
 
-KResult Plan9FSInode::ensure_open_for_mode(int mode)
+ErrorOr<void> Plan9FSInode::ensure_open_for_mode(int mode)
 {
     bool use_lopen = fs().m_remote_protocol_version >= Plan9FS::ProtocolVersion::v9P2000L;
     u32 l_mode = 0;
@@ -692,7 +692,7 @@ KResult Plan9FSInode::ensure_open_for_mode(int mode)
 
         // If it's already open in this mode, we're done.
         if ((m_open_mode & mode) == mode)
-            return KSuccess;
+            return {};
 
         m_open_mode |= mode;
 
@@ -718,7 +718,7 @@ KResult Plan9FSInode::ensure_open_for_mode(int mode)
     }
 }
 
-KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     TRY(const_cast<Plan9FSInode&>(*this).ensure_open_for_mode(O_RDONLY));
 
@@ -731,7 +731,7 @@ KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKern
     bool readlink_succeded = false;
     if (fs().m_remote_protocol_version >= Plan9FS::ProtocolVersion::v9P2000L && offset == 0) {
         message << fid();
-        if (auto result = fs().post_message_and_wait_for_a_reply(message); result.is_success()) {
+        if (auto result = fs().post_message_and_wait_for_a_reply(message); !result.is_error()) {
             readlink_succeded = true;
             message >> data;
         }
@@ -750,7 +750,7 @@ KResultOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKern
     return nread;
 }
 
-KResultOr<size_t> Plan9FSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& data, OpenFileDescription*)
+ErrorOr<size_t> Plan9FSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& data, OpenFileDescription*)
 {
     TRY(ensure_open_for_mode(O_WRONLY));
     size = fs().adjust_buffer_size(size);
@@ -822,13 +822,13 @@ InodeMetadata Plan9FSInode::metadata() const
     return metadata;
 }
 
-KResult Plan9FSInode::flush_metadata()
+ErrorOr<void> Plan9FSInode::flush_metadata()
 {
     // Do nothing.
-    return KSuccess;
+    return {};
 }
 
-KResult Plan9FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> Plan9FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     // TODO: Should we synthesize "." and ".." here?
 
@@ -853,7 +853,7 @@ KResult Plan9FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryE
 
         u64 offset = 0;
         u32 count = fs().adjust_buffer_size(8 * MiB);
-        KResult result = KSuccess;
+        ErrorOr<void> result;
 
         while (true) {
             Plan9FS::Message message { fs(), Plan9FS::Message::Type::Treaddir };
@@ -888,7 +888,7 @@ KResult Plan9FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryE
     }
 }
 
-KResultOr<NonnullRefPtr<Inode>> Plan9FSInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> Plan9FSInode::lookup(StringView name)
 {
     u32 newfid = fs().allocate_fid();
     Plan9FS::Message message { fs(), Plan9FS::Message::Type::Twalk };
@@ -897,37 +897,37 @@ KResultOr<NonnullRefPtr<Inode>> Plan9FSInode::lookup(StringView name)
     return TRY(Plan9FSInode::try_create(fs(), newfid));
 }
 
-KResultOr<NonnullRefPtr<Inode>> Plan9FSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
+ErrorOr<NonnullRefPtr<Inode>> Plan9FSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
 {
     // TODO
     return ENOTIMPL;
 }
 
-KResult Plan9FSInode::add_child(Inode&, const StringView&, mode_t)
+ErrorOr<void> Plan9FSInode::add_child(Inode&, const StringView&, mode_t)
 {
     // TODO
     return ENOTIMPL;
 }
 
-KResult Plan9FSInode::remove_child(const StringView&)
+ErrorOr<void> Plan9FSInode::remove_child(const StringView&)
 {
     // TODO
     return ENOTIMPL;
 }
 
-KResult Plan9FSInode::chmod(mode_t)
+ErrorOr<void> Plan9FSInode::chmod(mode_t)
 {
     // TODO
     return ENOTIMPL;
 }
 
-KResult Plan9FSInode::chown(UserID, GroupID)
+ErrorOr<void> Plan9FSInode::chown(UserID, GroupID)
 {
     // TODO
     return ENOTIMPL;
 }
 
-KResult Plan9FSInode::truncate(u64 new_size)
+ErrorOr<void> Plan9FSInode::truncate(u64 new_size)
 {
     if (fs().m_remote_protocol_version >= Plan9FS::ProtocolVersion::v9P2000L) {
         Plan9FS::Message message { fs(), Plan9FS::Message::Type::Tsetattr };
@@ -943,7 +943,7 @@ KResult Plan9FSInode::truncate(u64 new_size)
         return fs().post_message_and_wait_for_a_reply(message);
     } else {
         // TODO: wstat version
-        return KSuccess;
+        return {};
     }
 }
 
diff --git a/Kernel/FileSystem/Plan9FileSystem.h b/Kernel/FileSystem/Plan9FileSystem.h
index 835432b44e2..bf21e3f672f 100644
--- a/Kernel/FileSystem/Plan9FileSystem.h
+++ b/Kernel/FileSystem/Plan9FileSystem.h
@@ -20,9 +20,9 @@ class Plan9FS final : public FileBackedFileSystem {
 
 public:
     virtual ~Plan9FS() override;
-    static KResultOr<NonnullRefPtr<Plan9FS>> try_create(OpenFileDescription&);
+    static ErrorOr<NonnullRefPtr<Plan9FS>> try_create(OpenFileDescription&);
 
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
 
     virtual bool supports_watchers() const override { return false; }
 
@@ -74,7 +74,7 @@ private:
         bool completed { false };
         const u16 tag;
         OwnPtr<Message> message;
-        KResult result { KSuccess };
+        ErrorOr<void> result;
 
         ReceiveCompletion(u16 tag);
         ~ReceiveCompletion();
@@ -116,11 +116,11 @@ private:
     virtual StringView class_name() const override { return "Plan9FS"sv; }
 
     bool is_complete(const ReceiveCompletion&);
-    KResult post_message(Message&, RefPtr<ReceiveCompletion>);
-    KResult do_read(u8* buffer, size_t);
-    KResult read_and_dispatch_one_message();
-    KResult post_message_and_wait_for_a_reply(Message&);
-    KResult post_message_and_explicitly_ignore_reply(Message&);
+    ErrorOr<void> post_message(Message&, RefPtr<ReceiveCompletion>);
+    ErrorOr<void> do_read(u8* buffer, size_t);
+    ErrorOr<void> read_and_dispatch_one_message();
+    ErrorOr<void> post_message_and_wait_for_a_reply(Message&);
+    ErrorOr<void> post_message_and_explicitly_ignore_reply(Message&);
 
     ProtocolVersion parse_protocol_version(const StringView&) const;
     size_t adjust_buffer_size(size_t size) const;
@@ -155,21 +155,21 @@ public:
 
     // ^Inode
     virtual InodeMetadata metadata() const override;
-    virtual KResult flush_metadata() override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
-    virtual KResult remove_child(const StringView& name) override;
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
-    virtual KResult truncate(u64) override;
+    virtual ErrorOr<void> flush_metadata() override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> add_child(Inode&, const StringView& name, mode_t) override;
+    virtual ErrorOr<void> remove_child(const StringView& name) override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
+    virtual ErrorOr<void> truncate(u64) override;
 
 private:
     Plan9FSInode(Plan9FS&, u32 fid);
-    static KResultOr<NonnullRefPtr<Plan9FSInode>> try_create(Plan9FS&, u32 fid);
+    static ErrorOr<NonnullRefPtr<Plan9FSInode>> try_create(Plan9FS&, u32 fid);
 
     enum class GetAttrMask : u64 {
         Mode = 0x1,
@@ -206,7 +206,7 @@ private:
 
     // Mode in which the file is already open, using SerenityOS constants.
     int m_open_mode { 0 };
-    KResult ensure_open_for_mode(int mode);
+    ErrorOr<void> ensure_open_for_mode(int mode);
 
     Plan9FS& fs() { return reinterpret_cast<Plan9FS&>(Inode::fs()); }
     Plan9FS& fs() const
diff --git a/Kernel/FileSystem/ProcFS.cpp b/Kernel/FileSystem/ProcFS.cpp
index 62c101b3fa6..675541e4b8e 100644
--- a/Kernel/FileSystem/ProcFS.cpp
+++ b/Kernel/FileSystem/ProcFS.cpp
@@ -37,7 +37,7 @@ UNMAP_AFTER_INIT ProcFSComponentRegistry::ProcFSComponentRegistry()
 {
 }
 
-KResultOr<NonnullRefPtr<ProcFS>> ProcFS::try_create()
+ErrorOr<NonnullRefPtr<ProcFS>> ProcFS::try_create()
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFS());
 }
@@ -50,10 +50,10 @@ ProcFS::~ProcFS()
 {
 }
 
-KResult ProcFS::initialize()
+ErrorOr<void> ProcFS::initialize()
 {
     m_root_inode = static_ptr_cast<ProcFSDirectoryInode>(TRY(ProcFSComponentRegistry::the().root_directory().to_inode(*this)));
-    return KSuccess;
+    return {};
 }
 
 Inode& ProcFS::root_inode()
@@ -70,37 +70,37 @@ ProcFSInode::~ProcFSInode()
 {
 }
 
-KResult ProcFSInode::flush_metadata()
+ErrorOr<void> ProcFSInode::flush_metadata()
 {
-    return KSuccess;
+    return {};
 }
 
-KResult ProcFSInode::add_child(Inode&, const StringView&, mode_t)
+ErrorOr<void> ProcFSInode::add_child(Inode&, const StringView&, mode_t)
 {
     return EROFS;
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
+ErrorOr<NonnullRefPtr<Inode>> ProcFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
 {
     return EROFS;
 }
 
-KResult ProcFSInode::remove_child(const StringView&)
+ErrorOr<void> ProcFSInode::remove_child(const StringView&)
 {
     return EROFS;
 }
 
-KResult ProcFSInode::chmod(mode_t)
+ErrorOr<void> ProcFSInode::chmod(mode_t)
 {
     return EPERM;
 }
 
-KResult ProcFSInode::chown(UserID, GroupID)
+ErrorOr<void> ProcFSInode::chown(UserID, GroupID)
 {
     return EPERM;
 }
 
-KResultOr<NonnullRefPtr<ProcFSGlobalInode>> ProcFSGlobalInode::try_create(const ProcFS& fs, const ProcFSExposedComponent& component)
+ErrorOr<NonnullRefPtr<ProcFSGlobalInode>> ProcFSGlobalInode::try_create(const ProcFS& fs, const ProcFSExposedComponent& component)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSGlobalInode(fs, component));
 }
@@ -122,12 +122,12 @@ void ProcFSGlobalInode::did_seek(OpenFileDescription& description, off_t new_off
     }
 }
 
-KResult ProcFSGlobalInode::attach(OpenFileDescription& description)
+ErrorOr<void> ProcFSGlobalInode::attach(OpenFileDescription& description)
 {
     return m_associated_component->refresh_data(description);
 }
 
-KResultOr<size_t> ProcFSGlobalInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
+ErrorOr<size_t> ProcFSGlobalInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
 {
     return m_associated_component->read_bytes(offset, count, buffer, fd);
 }
@@ -137,22 +137,22 @@ StringView ProcFSGlobalInode::name() const
     return m_associated_component->name();
 }
 
-KResult ProcFSGlobalInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
+ErrorOr<void> ProcFSGlobalInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSGlobalInode::lookup(StringView)
+ErrorOr<NonnullRefPtr<Inode>> ProcFSGlobalInode::lookup(StringView)
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult ProcFSGlobalInode::truncate(u64 size)
+ErrorOr<void> ProcFSGlobalInode::truncate(u64 size)
 {
     return m_associated_component->truncate(size);
 }
 
-KResult ProcFSGlobalInode::set_mtime(time_t time)
+ErrorOr<void> ProcFSGlobalInode::set_mtime(time_t time)
 {
     return m_associated_component->set_mtime(time);
 }
@@ -170,12 +170,12 @@ InodeMetadata ProcFSGlobalInode::metadata() const
     return metadata;
 }
 
-KResultOr<size_t> ProcFSGlobalInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* fd)
+ErrorOr<size_t> ProcFSGlobalInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* fd)
 {
     return m_associated_component->write_bytes(offset, count, buffer, fd);
 }
 
-KResultOr<NonnullRefPtr<ProcFSDirectoryInode>> ProcFSDirectoryInode::try_create(const ProcFS& procfs, const ProcFSExposedComponent& component)
+ErrorOr<NonnullRefPtr<ProcFSDirectoryInode>> ProcFSDirectoryInode::try_create(const ProcFS& procfs, const ProcFSExposedComponent& component)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSDirectoryInode(procfs, component));
 }
@@ -200,20 +200,20 @@ InodeMetadata ProcFSDirectoryInode::metadata() const
     metadata.mtime = m_associated_component->modified_time();
     return metadata;
 }
-KResult ProcFSDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> ProcFSDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(procfs().m_lock);
     return m_associated_component->traverse_as_directory(procfs().fsid(), move(callback));
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSDirectoryInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> ProcFSDirectoryInode::lookup(StringView name)
 {
     MutexLocker locker(procfs().m_lock);
     auto component = TRY(m_associated_component->lookup(name));
     return component->to_inode(procfs());
 }
 
-KResultOr<NonnullRefPtr<ProcFSLinkInode>> ProcFSLinkInode::try_create(const ProcFS& procfs, const ProcFSExposedComponent& component)
+ErrorOr<NonnullRefPtr<ProcFSLinkInode>> ProcFSLinkInode::try_create(const ProcFS& procfs, const ProcFSExposedComponent& component)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSLinkInode(procfs, component));
 }
@@ -242,12 +242,12 @@ ProcFSProcessAssociatedInode::ProcFSProcessAssociatedInode(const ProcFS& fs, Pro
 {
 }
 
-KResultOr<size_t> ProcFSProcessAssociatedInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
+ErrorOr<size_t> ProcFSProcessAssociatedInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
 {
     return ENOTSUP;
 }
 
-KResultOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> ProcFSProcessDirectoryInode::try_create(const ProcFS& procfs, ProcessID pid)
+ErrorOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> ProcFSProcessDirectoryInode::try_create(const ProcFS& procfs, ProcessID pid)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessDirectoryInode(procfs, pid));
 }
@@ -257,9 +257,9 @@ ProcFSProcessDirectoryInode::ProcFSProcessDirectoryInode(const ProcFS& procfs, P
 {
 }
 
-KResult ProcFSProcessDirectoryInode::attach(OpenFileDescription&)
+ErrorOr<void> ProcFSProcessDirectoryInode::attach(OpenFileDescription&)
 {
-    return KSuccess;
+    return {};
 }
 
 InodeMetadata ProcFSProcessDirectoryInode::metadata() const
@@ -280,12 +280,12 @@ InodeMetadata ProcFSProcessDirectoryInode::metadata() const
     return metadata;
 }
 
-KResultOr<size_t> ProcFSProcessDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
+ErrorOr<size_t> ProcFSProcessDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult ProcFSProcessDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> ProcFSProcessDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(procfs().m_lock);
     auto process = Process::from_pid(associated_pid());
@@ -294,7 +294,7 @@ KResult ProcFSProcessDirectoryInode::traverse_as_directory(Function<bool(FileSys
     return process->procfs_traits()->traverse_as_directory(procfs().fsid(), move(callback));
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView name)
 {
     MutexLocker locker(procfs().m_lock);
     auto process = Process::from_pid(associated_pid());
@@ -321,7 +321,7 @@ KResultOr<NonnullRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView n
     return ENOENT;
 }
 
-KResultOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> ProcFSProcessSubDirectoryInode::try_create(const ProcFS& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
+ErrorOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> ProcFSProcessSubDirectoryInode::try_create(const ProcFS& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessSubDirectoryInode(procfs, sub_directory_type, pid));
 }
@@ -332,14 +332,14 @@ ProcFSProcessSubDirectoryInode::ProcFSProcessSubDirectoryInode(const ProcFS& pro
 {
 }
 
-KResultOr<size_t> ProcFSProcessSubDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
+ErrorOr<size_t> ProcFSProcessSubDirectoryInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResult ProcFSProcessSubDirectoryInode::attach(OpenFileDescription&)
+ErrorOr<void> ProcFSProcessSubDirectoryInode::attach(OpenFileDescription&)
 {
-    return KSuccess;
+    return {};
 }
 
 void ProcFSProcessSubDirectoryInode::did_seek(OpenFileDescription&, off_t)
@@ -365,7 +365,7 @@ InodeMetadata ProcFSProcessSubDirectoryInode::metadata() const
     return metadata;
 }
 
-KResult ProcFSProcessSubDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> ProcFSProcessSubDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(procfs().m_lock);
     auto process = Process::from_pid(associated_pid());
@@ -382,7 +382,7 @@ KResult ProcFSProcessSubDirectoryInode::traverse_as_directory(Function<bool(File
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSProcessSubDirectoryInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> ProcFSProcessSubDirectoryInode::lookup(StringView name)
 {
     MutexLocker locker(procfs().m_lock);
     auto process = Process::from_pid(associated_pid());
@@ -398,15 +398,15 @@ KResultOr<NonnullRefPtr<Inode>> ProcFSProcessSubDirectoryInode::lookup(StringVie
     }
 }
 
-KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_file_description_link(const ProcFS& procfs, unsigned file_description_index, ProcessID pid)
+ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_file_description_link(const ProcFS& procfs, unsigned file_description_index, ProcessID pid)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, file_description_index, pid));
 }
-KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_thread_stack(const ProcFS& procfs, ThreadID stack_thread_index, ProcessID pid)
+ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_thread_stack(const ProcFS& procfs, ThreadID stack_thread_index, ProcessID pid)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, stack_thread_index, pid));
 }
-KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_pid_property(const ProcFS& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
+ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_pid_property(const ProcFS& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, main_property_type, pid));
 }
@@ -432,7 +432,7 @@ ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(const ProcFS& procfs, Thr
     m_possible_data.property_index = thread_stack_index.value();
 }
 
-KResult ProcFSProcessPropertyInode::attach(OpenFileDescription& description)
+ErrorOr<void> ProcFSProcessPropertyInode::attach(OpenFileDescription& description)
 {
     return refresh_data(description);
 }
@@ -474,11 +474,11 @@ InodeMetadata ProcFSProcessPropertyInode::metadata() const
     metadata.mtime = traits->modified_time();
     return metadata;
 }
-KResult ProcFSProcessPropertyInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
+ErrorOr<void> ProcFSProcessPropertyInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
 {
     VERIFY_NOT_REACHED();
 }
-KResultOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
+ErrorOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     dbgln_if(PROCFS_DEBUG, "ProcFS ProcessInformation: read_bytes offset: {} count: {}", offset, count);
 
@@ -489,18 +489,18 @@ KResultOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t co
         auto builder = TRY(KBufferBuilder::try_create());
         auto process = Process::from_pid(associated_pid());
         if (!process)
-            return KResult(ESRCH);
+            return Error::from_errno(ESRCH);
         TRY(try_to_acquire_data(*process, builder));
         auto data_buffer = builder.build();
         if (!data_buffer)
-            return KResult(EFAULT);
+            return Error::from_errno(EFAULT);
         ssize_t nread = min(static_cast<off_t>(data_buffer->size() - offset), static_cast<off_t>(count));
         TRY(buffer.write(data_buffer->data() + offset, nread));
         return nread;
     }
     if (!description->data()) {
         dbgln("ProcFS Process Information: Do not have cached data!");
-        return KResult(EIO);
+        return Error::from_errno(EIO);
     }
 
     MutexLocker locker(m_refresh_lock);
@@ -516,29 +516,29 @@ KResultOr<size_t> ProcFSProcessPropertyInode::read_bytes(off_t offset, size_t co
 
     return nread;
 }
-KResultOr<NonnullRefPtr<Inode>> ProcFSProcessPropertyInode::lookup(StringView)
+ErrorOr<NonnullRefPtr<Inode>> ProcFSProcessPropertyInode::lookup(StringView)
 {
     return EINVAL;
 }
 
-static KResult build_from_cached_data(KBufferBuilder& builder, ProcFSInodeData& cached_data)
+static ErrorOr<void> build_from_cached_data(KBufferBuilder& builder, ProcFSInodeData& cached_data)
 {
     cached_data.buffer = builder.build();
     if (!cached_data.buffer)
         return ENOMEM;
-    return KSuccess;
+    return {};
 }
 
-KResult ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBufferBuilder& builder) const
+ErrorOr<void> ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBufferBuilder& builder) const
 {
     // FIXME: Verify process is already ref-counted
     if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions) {
         TRY(process.procfs_get_file_description_link(m_possible_data.property_index, builder));
-        return KSuccess;
+        return {};
     }
     if (m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Stacks) {
         TRY(process.procfs_get_thread_stack(m_possible_data.property_index, builder));
-        return KSuccess;
+        return {};
     }
 
     VERIFY(m_parent_sub_directory_type == SegmentedProcFSIndex::ProcessSubDirectory::Reserved);
@@ -562,14 +562,14 @@ KResult ProcFSProcessPropertyInode::try_to_acquire_data(Process& process, KBuffe
     }
 }
 
-KResult ProcFSProcessPropertyInode::refresh_data(OpenFileDescription& description)
+ErrorOr<void> ProcFSProcessPropertyInode::refresh_data(OpenFileDescription& description)
 {
     // For process-specific inodes, hold the process's ptrace lock across refresh
     // and refuse to load data if the process is not dumpable.
     // Without this, files opened before a process went non-dumpable could still be used for dumping.
     auto process = Process::from_pid(associated_pid());
     if (!process)
-        return KResult(ESRCH);
+        return Error::from_errno(ESRCH);
     process->ptrace_lock().lock();
     if (!process->is_dumpable()) {
         process->ptrace_lock().unlock();
diff --git a/Kernel/FileSystem/ProcFS.h b/Kernel/FileSystem/ProcFS.h
index abd525ea5b2..7801ddbf729 100644
--- a/Kernel/FileSystem/ProcFS.h
+++ b/Kernel/FileSystem/ProcFS.h
@@ -28,9 +28,9 @@ class ProcFS final : public FileSystem {
 
 public:
     virtual ~ProcFS() override;
-    static KResultOr<NonnullRefPtr<ProcFS>> try_create();
+    static ErrorOr<NonnullRefPtr<ProcFS>> try_create();
 
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
     virtual StringView class_name() const override { return "ProcFS"sv; }
 
     virtual Inode& root_inode() override;
@@ -54,21 +54,21 @@ protected:
     ProcFS const& procfs() const { return static_cast<ProcFS const&>(Inode::fs()); }
 
     // ^Inode
-    virtual KResult attach(OpenFileDescription& description) = 0;
+    virtual ErrorOr<void> attach(OpenFileDescription& description) = 0;
     virtual void did_seek(OpenFileDescription&, off_t) = 0;
-    virtual KResult flush_metadata() override final;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override final;
-    virtual KResult add_child(Inode&, const StringView& name, mode_t) override final;
-    virtual KResult remove_child(const StringView& name) override final;
-    virtual KResult chmod(mode_t) override final;
-    virtual KResult chown(UserID, GroupID) override final;
+    virtual ErrorOr<void> flush_metadata() override final;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override final;
+    virtual ErrorOr<void> add_child(Inode&, const StringView& name, mode_t) override final;
+    virtual ErrorOr<void> remove_child(const StringView& name) override final;
+    virtual ErrorOr<void> chmod(mode_t) override final;
+    virtual ErrorOr<void> chown(UserID, GroupID) override final;
 };
 
 class ProcFSGlobalInode : public ProcFSInode {
     friend class ProcFS;
 
 public:
-    static KResultOr<NonnullRefPtr<ProcFSGlobalInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
+    static ErrorOr<NonnullRefPtr<ProcFSGlobalInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
     virtual ~ProcFSGlobalInode() override {};
     StringView name() const;
 
@@ -76,15 +76,15 @@ protected:
     ProcFSGlobalInode(const ProcFS&, const ProcFSExposedComponent&);
 
     // ^Inode
-    virtual KResult attach(OpenFileDescription& description) override final;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
+    virtual ErrorOr<void> attach(OpenFileDescription& description) override final;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
     virtual void did_seek(OpenFileDescription&, off_t) override final;
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView) override;
-    virtual KResult truncate(u64) override final;
-    virtual KResult set_mtime(time_t) override final;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView) override;
+    virtual ErrorOr<void> truncate(u64) override final;
+    virtual ErrorOr<void> set_mtime(time_t) override final;
 
     NonnullRefPtr<ProcFSExposedComponent> m_associated_component;
 };
@@ -93,7 +93,7 @@ class ProcFSLinkInode : public ProcFSGlobalInode {
     friend class ProcFS;
 
 public:
-    static KResultOr<NonnullRefPtr<ProcFSLinkInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
+    static ErrorOr<NonnullRefPtr<ProcFSLinkInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
 
 protected:
     ProcFSLinkInode(const ProcFS&, const ProcFSExposedComponent&);
@@ -104,15 +104,15 @@ class ProcFSDirectoryInode final : public ProcFSGlobalInode {
     friend class ProcFS;
 
 public:
-    static KResultOr<NonnullRefPtr<ProcFSDirectoryInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
+    static ErrorOr<NonnullRefPtr<ProcFSDirectoryInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
     virtual ~ProcFSDirectoryInode() override;
 
 protected:
     ProcFSDirectoryInode(const ProcFS&, const ProcFSExposedComponent&);
     // ^Inode
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
 };
 
 class ProcFSProcessAssociatedInode : public ProcFSInode {
@@ -123,7 +123,7 @@ protected:
     ProcessID associated_pid() const { return m_pid; }
 
     // ^Inode
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
 
 private:
     const ProcessID m_pid;
@@ -133,34 +133,34 @@ class ProcFSProcessDirectoryInode final : public ProcFSProcessAssociatedInode {
     friend class ProcFS;
 
 public:
-    static KResultOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> try_create(const ProcFS&, ProcessID);
+    static ErrorOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> try_create(const ProcFS&, ProcessID);
 
 private:
     ProcFSProcessDirectoryInode(const ProcFS&, ProcessID);
     // ^Inode
-    virtual KResult attach(OpenFileDescription& description) override;
+    virtual ErrorOr<void> attach(OpenFileDescription& description) override;
     virtual void did_seek(OpenFileDescription&, off_t) override { }
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
 };
 
 class ProcFSProcessSubDirectoryInode final : public ProcFSProcessAssociatedInode {
     friend class ProcFS;
 
 public:
-    static KResultOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> try_create(const ProcFS&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
+    static ErrorOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> try_create(const ProcFS&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
 
 private:
     ProcFSProcessSubDirectoryInode(const ProcFS&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
     // ^Inode
-    virtual KResult attach(OpenFileDescription& description) override;
+    virtual ErrorOr<void> attach(OpenFileDescription& description) override;
     virtual void did_seek(OpenFileDescription&, off_t) override;
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
 
     const SegmentedProcFSIndex::ProcessSubDirectory m_sub_directory_type;
 };
@@ -169,24 +169,24 @@ class ProcFSProcessPropertyInode final : public ProcFSProcessAssociatedInode {
     friend class ProcFS;
 
 public:
-    static KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_file_description_link(const ProcFS&, unsigned, ProcessID);
-    static KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_thread_stack(const ProcFS&, ThreadID, ProcessID);
-    static KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_pid_property(const ProcFS&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
+    static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_file_description_link(const ProcFS&, unsigned, ProcessID);
+    static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_thread_stack(const ProcFS&, ThreadID, ProcessID);
+    static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_pid_property(const ProcFS&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
 
 private:
     ProcFSProcessPropertyInode(const ProcFS&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
     ProcFSProcessPropertyInode(const ProcFS&, ThreadID, ProcessID);
     ProcFSProcessPropertyInode(const ProcFS&, unsigned, ProcessID);
     // ^Inode
-    virtual KResult attach(OpenFileDescription& description) override;
+    virtual ErrorOr<void> attach(OpenFileDescription& description) override;
     virtual void did_seek(OpenFileDescription&, off_t) override;
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override final;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override final;
 
-    KResult refresh_data(OpenFileDescription& description);
-    KResult try_to_acquire_data(Process& process, KBufferBuilder& builder) const;
+    ErrorOr<void> refresh_data(OpenFileDescription& description);
+    ErrorOr<void> try_to_acquire_data(Process& process, KBufferBuilder& builder) const;
 
     const SegmentedProcFSIndex::ProcessSubDirectory m_parent_sub_directory_type;
     union {
diff --git a/Kernel/FileSystem/SysFS.cpp b/Kernel/FileSystem/SysFS.cpp
index e45da8a7337..b4a9614822e 100644
--- a/Kernel/FileSystem/SysFS.cpp
+++ b/Kernel/FileSystem/SysFS.cpp
@@ -46,7 +46,7 @@ NonnullRefPtr<SysFSRootDirectory> SysFSRootDirectory::create()
     return adopt_ref(*new (nothrow) SysFSRootDirectory);
 }
 
-KResult SysFSRootDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> SysFSRootDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(SysFSComponentRegistry::the().get_lock());
     callback({ ".", { fsid, component_index() }, 0 });
@@ -56,7 +56,7 @@ KResult SysFSRootDirectory::traverse_as_directory(unsigned fsid, Function<bool(F
         InodeIdentifier identifier = { fsid, component.component_index() };
         callback({ component.name(), identifier, 0 });
     }
-    return KSuccess;
+    return {};
 }
 
 SysFSRootDirectory::SysFSRootDirectory()
@@ -69,7 +69,7 @@ SysFSRootDirectory::SysFSRootDirectory()
     m_buses_directory = buses_directory;
 }
 
-KResultOr<NonnullRefPtr<SysFS>> SysFS::try_create()
+ErrorOr<NonnullRefPtr<SysFS>> SysFS::try_create()
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) SysFS);
 }
@@ -82,10 +82,10 @@ SysFS::~SysFS()
 {
 }
 
-KResult SysFS::initialize()
+ErrorOr<void> SysFS::initialize()
 {
     m_root_inode = TRY(SysFSComponentRegistry::the().root_directory().to_inode(*this));
-    return KSuccess;
+    return {};
 }
 
 Inode& SysFS::root_inode()
@@ -93,7 +93,7 @@ Inode& SysFS::root_inode()
     return *m_root_inode;
 }
 
-KResultOr<NonnullRefPtr<SysFSInode>> SysFSInode::try_create(SysFS const& fs, SysFSComponent const& component)
+ErrorOr<NonnullRefPtr<SysFSInode>> SysFSInode::try_create(SysFS const& fs, SysFSComponent const& component)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) SysFSInode(fs, component));
 }
@@ -115,22 +115,22 @@ void SysFSInode::did_seek(OpenFileDescription& description, off_t new_offset)
     }
 }
 
-KResult SysFSInode::attach(OpenFileDescription& description)
+ErrorOr<void> SysFSInode::attach(OpenFileDescription& description)
 {
     return m_associated_component->refresh_data(description);
 }
 
-KResultOr<size_t> SysFSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
+ErrorOr<size_t> SysFSInode::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* fd) const
 {
     return m_associated_component->read_bytes(offset, count, buffer, fd);
 }
 
-KResult SysFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
+ErrorOr<void> SysFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const
 {
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<NonnullRefPtr<Inode>> SysFSInode::lookup(StringView)
+ErrorOr<NonnullRefPtr<Inode>> SysFSInode::lookup(StringView)
 {
     VERIFY_NOT_REACHED();
 }
@@ -148,52 +148,52 @@ InodeMetadata SysFSInode::metadata() const
     return metadata;
 }
 
-KResult SysFSInode::flush_metadata()
+ErrorOr<void> SysFSInode::flush_metadata()
 {
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> SysFSInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* fd)
+ErrorOr<size_t> SysFSInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* fd)
 {
     return m_associated_component->write_bytes(offset, count, buffer, fd);
 }
 
-KResultOr<NonnullRefPtr<Inode>> SysFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
+ErrorOr<NonnullRefPtr<Inode>> SysFSInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
 {
     return EROFS;
 }
 
-KResult SysFSInode::add_child(Inode&, StringView const&, mode_t)
+ErrorOr<void> SysFSInode::add_child(Inode&, StringView const&, mode_t)
 {
     return EROFS;
 }
 
-KResult SysFSInode::remove_child(StringView const&)
+ErrorOr<void> SysFSInode::remove_child(StringView const&)
 {
     return EROFS;
 }
 
-KResult SysFSInode::chmod(mode_t)
+ErrorOr<void> SysFSInode::chmod(mode_t)
 {
     return EPERM;
 }
 
-KResult SysFSInode::chown(UserID, GroupID)
+ErrorOr<void> SysFSInode::chown(UserID, GroupID)
 {
     return EPERM;
 }
 
-KResult SysFSInode::set_mtime(time_t time)
+ErrorOr<void> SysFSInode::set_mtime(time_t time)
 {
     return m_associated_component->set_mtime(time);
 }
 
-KResult SysFSInode::truncate(u64 size)
+ErrorOr<void> SysFSInode::truncate(u64 size)
 {
     return m_associated_component->truncate(size);
 }
 
-KResultOr<NonnullRefPtr<SysFSDirectoryInode>> SysFSDirectoryInode::try_create(SysFS const& sysfs, SysFSComponent const& component)
+ErrorOr<NonnullRefPtr<SysFSDirectoryInode>> SysFSDirectoryInode::try_create(SysFS const& sysfs, SysFSComponent const& component)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) SysFSDirectoryInode(sysfs, component));
 }
@@ -219,13 +219,13 @@ InodeMetadata SysFSDirectoryInode::metadata() const
     metadata.mtime = mepoch;
     return metadata;
 }
-KResult SysFSDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> SysFSDirectoryInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(fs().m_lock);
     return m_associated_component->traverse_as_directory(fs().fsid(), move(callback));
 }
 
-KResultOr<NonnullRefPtr<Inode>> SysFSDirectoryInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> SysFSDirectoryInode::lookup(StringView name)
 {
     MutexLocker locker(fs().m_lock);
     auto component = m_associated_component->lookup(name);
diff --git a/Kernel/FileSystem/SysFS.h b/Kernel/FileSystem/SysFS.h
index d62781f48c4..2a8a8a45182 100644
--- a/Kernel/FileSystem/SysFS.h
+++ b/Kernel/FileSystem/SysFS.h
@@ -19,7 +19,7 @@ class SysFSRootDirectory final : public SysFSDirectory {
 
 public:
     static NonnullRefPtr<SysFSRootDirectory> create();
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
 
 private:
     SysFSRootDirectory();
@@ -53,7 +53,7 @@ private:
 class SysFSBlockDevicesDirectory final : public SysFSDirectory {
 public:
     static NonnullRefPtr<SysFSBlockDevicesDirectory> must_create(SysFSDevicesDirectory const&);
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual RefPtr<SysFSComponent> lookup(StringView name) override;
 
 private:
@@ -63,7 +63,7 @@ private:
 class SysFSCharacterDevicesDirectory final : public SysFSDirectory {
 public:
     static NonnullRefPtr<SysFSCharacterDevicesDirectory> must_create(SysFSDevicesDirectory const&);
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual RefPtr<SysFSComponent> lookup(StringView name) override;
 
 private:
@@ -111,9 +111,9 @@ class SysFS final : public FileSystem {
 
 public:
     virtual ~SysFS() override;
-    static KResultOr<NonnullRefPtr<SysFS>> try_create();
+    static ErrorOr<NonnullRefPtr<SysFS>> try_create();
 
-    virtual KResult initialize() override;
+    virtual ErrorOr<void> initialize() override;
     virtual StringView class_name() const override { return "SysFS"sv; }
 
     virtual Inode& root_inode() override;
@@ -129,26 +129,26 @@ class SysFSInode : public Inode {
     friend class SysFSDirectoryInode;
 
 public:
-    static KResultOr<NonnullRefPtr<SysFSInode>> try_create(SysFS const&, SysFSComponent const&);
+    static ErrorOr<NonnullRefPtr<SysFSInode>> try_create(SysFS const&, SysFSComponent const&);
     StringView name() const { return m_associated_component->name(); }
 
 protected:
     SysFSInode(SysFS const&, SysFSComponent const&);
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
-    virtual KResult flush_metadata() override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> flush_metadata() override;
     virtual InodeMetadata metadata() const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) override;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult add_child(Inode&, StringView const& name, mode_t) override;
-    virtual KResult remove_child(StringView const& name) override;
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
-    virtual KResult truncate(u64) override;
-    virtual KResult set_mtime(time_t);
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> add_child(Inode&, StringView const& name, mode_t) override;
+    virtual ErrorOr<void> remove_child(StringView const& name) override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
+    virtual ErrorOr<void> truncate(u64) override;
+    virtual ErrorOr<void> set_mtime(time_t);
 
-    virtual KResult attach(OpenFileDescription& description) override final;
+    virtual ErrorOr<void> attach(OpenFileDescription& description) override final;
     virtual void did_seek(OpenFileDescription&, off_t) override final;
 
     NonnullRefPtr<SysFSComponent> m_associated_component;
@@ -158,7 +158,7 @@ class SysFSDirectoryInode : public SysFSInode {
     friend class SysFS;
 
 public:
-    static KResultOr<NonnullRefPtr<SysFSDirectoryInode>> try_create(SysFS const&, SysFSComponent const&);
+    static ErrorOr<NonnullRefPtr<SysFSDirectoryInode>> try_create(SysFS const&, SysFSComponent const&);
     virtual ~SysFSDirectoryInode() override;
 
     SysFS& fs() { return static_cast<SysFS&>(Inode::fs()); }
@@ -168,8 +168,8 @@ protected:
     SysFSDirectoryInode(SysFS const&, SysFSComponent const&);
     // ^Inode
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
 };
 
 }
diff --git a/Kernel/FileSystem/SysFSComponent.cpp b/Kernel/FileSystem/SysFSComponent.cpp
index a2cd1db4e60..807a129ab7b 100644
--- a/Kernel/FileSystem/SysFSComponent.cpp
+++ b/Kernel/FileSystem/SysFSComponent.cpp
@@ -31,7 +31,7 @@ mode_t SysFSComponent::permissions() const
     return S_IRUSR | S_IRGRP | S_IROTH;
 }
 
-KResult SysFSDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> SysFSDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(SysFSComponentRegistry::the().get_lock());
     VERIFY(m_parent_directory);
@@ -42,7 +42,7 @@ KResult SysFSDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileS
         InodeIdentifier identifier = { fsid, component.component_index() };
         callback({ component.name(), identifier, 0 });
     }
-    return KSuccess;
+    return {};
 }
 
 RefPtr<SysFSComponent> SysFSDirectory::lookup(StringView name)
@@ -66,12 +66,12 @@ SysFSDirectory::SysFSDirectory(StringView name, SysFSDirectory const& parent_dir
 {
 }
 
-KResultOr<NonnullRefPtr<SysFSInode>> SysFSDirectory::to_inode(SysFS const& sysfs_instance) const
+ErrorOr<NonnullRefPtr<SysFSInode>> SysFSDirectory::to_inode(SysFS const& sysfs_instance) const
 {
     return TRY(SysFSDirectoryInode::try_create(sysfs_instance, *this));
 }
 
-KResultOr<NonnullRefPtr<SysFSInode>> SysFSComponent::to_inode(SysFS const& sysfs_instance) const
+ErrorOr<NonnullRefPtr<SysFSInode>> SysFSComponent::to_inode(SysFS const& sysfs_instance) const
 {
     return SysFSInode::try_create(sysfs_instance, *this);
 }
diff --git a/Kernel/FileSystem/SysFSComponent.h b/Kernel/FileSystem/SysFSComponent.h
index 6e29c1ed82e..e42620d419c 100644
--- a/Kernel/FileSystem/SysFSComponent.h
+++ b/Kernel/FileSystem/SysFSComponent.h
@@ -6,12 +6,12 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/Function.h>
 #include <AK/RefCounted.h>
 #include <AK/RefPtr.h>
 #include <AK/StringView.h>
 #include <AK/Types.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/File.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/OpenFileDescription.h>
@@ -26,16 +26,16 @@ struct SysFSInodeData : public OpenFileDescriptionData {
 class SysFSComponent : public RefCounted<SysFSComponent> {
 public:
     virtual StringView name() const { return m_name->view(); }
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const { return KResult(ENOTIMPL); }
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const { VERIFY_NOT_REACHED(); }
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const { return Error::from_errno(ENOTIMPL); }
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const { VERIFY_NOT_REACHED(); }
     virtual RefPtr<SysFSComponent> lookup(StringView) { VERIFY_NOT_REACHED(); };
     virtual mode_t permissions() const;
-    virtual KResult truncate(u64) { return EPERM; }
-    virtual KResult set_mtime(time_t) { return ENOTIMPL; }
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) { return EROFS; }
-    virtual KResult refresh_data(OpenFileDescription&) const { return KSuccess; }
+    virtual ErrorOr<void> truncate(u64) { return EPERM; }
+    virtual ErrorOr<void> set_mtime(time_t) { return ENOTIMPL; }
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) { return EROFS; }
+    virtual ErrorOr<void> refresh_data(OpenFileDescription&) const { return {}; }
 
-    virtual KResultOr<NonnullRefPtr<SysFSInode>> to_inode(SysFS const&) const;
+    virtual ErrorOr<NonnullRefPtr<SysFSInode>> to_inode(SysFS const&) const;
 
     InodeIndex component_index() const { return m_component_index; };
 
@@ -51,10 +51,10 @@ private:
 
 class SysFSDirectory : public SysFSComponent {
 public:
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     virtual RefPtr<SysFSComponent> lookup(StringView name) override;
 
-    virtual KResultOr<NonnullRefPtr<SysFSInode>> to_inode(SysFS const& sysfs_instance) const override final;
+    virtual ErrorOr<NonnullRefPtr<SysFSInode>> to_inode(SysFS const& sysfs_instance) const override final;
 
 protected:
     explicit SysFSDirectory(StringView name);
diff --git a/Kernel/FileSystem/TmpFS.cpp b/Kernel/FileSystem/TmpFS.cpp
index 17115a093a9..824c04a1064 100644
--- a/Kernel/FileSystem/TmpFS.cpp
+++ b/Kernel/FileSystem/TmpFS.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<TmpFS>> TmpFS::try_create()
+ErrorOr<NonnullRefPtr<TmpFS>> TmpFS::try_create()
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) TmpFS);
 }
@@ -23,10 +23,10 @@ TmpFS::~TmpFS()
 {
 }
 
-KResult TmpFS::initialize()
+ErrorOr<void> TmpFS::initialize()
 {
     m_root_inode = TRY(TmpFSInode::try_create_root(*this));
-    return KSuccess;
+    return {};
 }
 
 Inode& TmpFS::root_inode()
@@ -59,7 +59,7 @@ unsigned TmpFS::next_inode_index()
     return m_next_inode_index++;
 }
 
-KResultOr<NonnullRefPtr<Inode>> TmpFS::get_inode(InodeIdentifier identifier) const
+ErrorOr<NonnullRefPtr<Inode>> TmpFS::get_inode(InodeIdentifier identifier) const
 {
     MutexLocker locker(m_lock, Mutex::Mode::Shared);
     VERIFY(identifier.fsid() == fsid());
@@ -82,14 +82,14 @@ TmpFSInode::~TmpFSInode()
 {
 }
 
-KResultOr<NonnullRefPtr<TmpFSInode>> TmpFSInode::try_create(TmpFS& fs, InodeMetadata const& metadata, InodeIdentifier parent)
+ErrorOr<NonnullRefPtr<TmpFSInode>> TmpFSInode::try_create(TmpFS& fs, InodeMetadata const& metadata, InodeIdentifier parent)
 {
     auto inode = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) TmpFSInode(fs, metadata, parent)));
     fs.register_inode(inode);
     return inode;
 }
 
-KResultOr<NonnullRefPtr<TmpFSInode>> TmpFSInode::try_create_root(TmpFS& fs)
+ErrorOr<NonnullRefPtr<TmpFSInode>> TmpFSInode::try_create_root(TmpFS& fs)
 {
     InodeMetadata metadata;
     auto now = kgettimeofday().to_truncated_seconds();
@@ -107,7 +107,7 @@ InodeMetadata TmpFSInode::metadata() const
     return m_metadata;
 }
 
-KResult TmpFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> TmpFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(m_inode_lock, Mutex::Mode::Shared);
 
@@ -120,10 +120,10 @@ KResult TmpFSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEnt
     for (auto& child : m_children) {
         callback({ child.name->view(), child.inode->identifier(), 0 });
     }
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     MutexLocker locker(m_inode_lock, Mutex::Mode::Shared);
     VERIFY(!is_directory());
@@ -142,7 +142,7 @@ KResultOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernel
     return size;
 }
 
-KResultOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& buffer, OpenFileDescription*)
+ErrorOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& buffer, OpenFileDescription*)
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(!is_directory());
@@ -185,7 +185,7 @@ KResultOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserO
     return size;
 }
 
-KResultOr<NonnullRefPtr<Inode>> TmpFSInode::lookup(StringView name)
+ErrorOr<NonnullRefPtr<Inode>> TmpFSInode::lookup(StringView name)
 {
     MutexLocker locker(m_inode_lock, Mutex::Mode::Shared);
     VERIFY(is_directory());
@@ -216,7 +216,7 @@ void TmpFSInode::notify_watchers()
     set_metadata_dirty(false);
 }
 
-KResult TmpFSInode::flush_metadata()
+ErrorOr<void> TmpFSInode::flush_metadata()
 {
     // We don't really have any metadata that could become dirty.
     // The only reason we even call set_metadata_dirty() is
@@ -224,29 +224,29 @@ KResult TmpFSInode::flush_metadata()
     // switched to a different mechanism, we can stop ever marking
     // our metadata as dirty at all.
     set_metadata_dirty(false);
-    return KSuccess;
+    return {};
 }
 
-KResult TmpFSInode::chmod(mode_t mode)
+ErrorOr<void> TmpFSInode::chmod(mode_t mode)
 {
     MutexLocker locker(m_inode_lock);
 
     m_metadata.mode = mode;
     notify_watchers();
-    return KSuccess;
+    return {};
 }
 
-KResult TmpFSInode::chown(UserID uid, GroupID gid)
+ErrorOr<void> TmpFSInode::chown(UserID uid, GroupID gid)
 {
     MutexLocker locker(m_inode_lock);
 
     m_metadata.uid = uid;
     m_metadata.gid = gid;
     notify_watchers();
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> TmpFSInode::create_child(StringView name, mode_t mode, dev_t dev, UserID uid, GroupID gid)
+ErrorOr<NonnullRefPtr<Inode>> TmpFSInode::create_child(StringView name, mode_t mode, dev_t dev, UserID uid, GroupID gid)
 {
     MutexLocker locker(m_inode_lock);
 
@@ -269,7 +269,7 @@ KResultOr<NonnullRefPtr<Inode>> TmpFSInode::create_child(StringView name, mode_t
     return child;
 }
 
-KResult TmpFSInode::add_child(Inode& child, StringView const& name, mode_t)
+ErrorOr<void> TmpFSInode::add_child(Inode& child, StringView const& name, mode_t)
 {
     VERIFY(is_directory());
     VERIFY(child.fsid() == fsid());
@@ -286,16 +286,16 @@ KResult TmpFSInode::add_child(Inode& child, StringView const& name, mode_t)
     MutexLocker locker(m_inode_lock);
     m_children.append(*child_entry);
     did_add_child(child.identifier(), name);
-    return KSuccess;
+    return {};
 }
 
-KResult TmpFSInode::remove_child(StringView const& name)
+ErrorOr<void> TmpFSInode::remove_child(StringView const& name)
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(is_directory());
 
     if (name == "." || name == "..")
-        return KSuccess;
+        return {};
 
     auto* child = find_child_by_name(name);
     if (!child)
@@ -307,10 +307,10 @@ KResult TmpFSInode::remove_child(StringView const& name)
     did_remove_child(child_id, name);
     // Balanced by `new` in add_child()
     delete child;
-    return KSuccess;
+    return {};
 }
 
-KResult TmpFSInode::truncate(u64 size)
+ErrorOr<void> TmpFSInode::truncate(u64 size)
 {
     MutexLocker locker(m_inode_lock);
     VERIFY(!is_directory());
@@ -333,34 +333,34 @@ KResult TmpFSInode::truncate(u64 size)
 
     m_metadata.size = size;
     notify_watchers();
-    return KSuccess;
+    return {};
 }
 
-KResult TmpFSInode::set_atime(time_t time)
+ErrorOr<void> TmpFSInode::set_atime(time_t time)
 {
     MutexLocker locker(m_inode_lock);
 
     m_metadata.atime = time;
     notify_watchers();
-    return KSuccess;
+    return {};
 }
 
-KResult TmpFSInode::set_ctime(time_t time)
+ErrorOr<void> TmpFSInode::set_ctime(time_t time)
 {
     MutexLocker locker(m_inode_lock);
 
     m_metadata.ctime = time;
     notify_watchers();
-    return KSuccess;
+    return {};
 }
 
-KResult TmpFSInode::set_mtime(time_t t)
+ErrorOr<void> TmpFSInode::set_mtime(time_t t)
 {
     MutexLocker locker(m_inode_lock);
 
     m_metadata.mtime = t;
     notify_watchers();
-    return KSuccess;
+    return {};
 }
 
 void TmpFSInode::one_ref_left()
diff --git a/Kernel/FileSystem/TmpFS.h b/Kernel/FileSystem/TmpFS.h
index c13cc908f27..91529647299 100644
--- a/Kernel/FileSystem/TmpFS.h
+++ b/Kernel/FileSystem/TmpFS.h
@@ -19,8 +19,8 @@ class TmpFS final : public FileSystem {
 
 public:
     virtual ~TmpFS() override;
-    static KResultOr<NonnullRefPtr<TmpFS>> try_create();
-    virtual KResult initialize() override;
+    static ErrorOr<NonnullRefPtr<TmpFS>> try_create();
+    virtual ErrorOr<void> initialize() override;
 
     virtual StringView class_name() const override { return "TmpFS"sv; }
 
@@ -34,7 +34,7 @@ private:
     RefPtr<TmpFSInode> m_root_inode;
 
     HashMap<InodeIndex, NonnullRefPtr<TmpFSInode>> m_inodes;
-    KResultOr<NonnullRefPtr<Inode>> get_inode(InodeIdentifier identifier) const;
+    ErrorOr<NonnullRefPtr<Inode>> get_inode(InodeIdentifier identifier) const;
     void register_inode(TmpFSInode&);
     void unregister_inode(InodeIdentifier);
 
@@ -52,27 +52,27 @@ public:
     const TmpFS& fs() const { return static_cast<const TmpFS&>(Inode::fs()); }
 
     // ^Inode
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
     virtual InodeMetadata metadata() const override;
-    virtual KResult traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
-    virtual KResult flush_metadata() override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
-    virtual KResultOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
-    virtual KResult add_child(Inode&, const StringView& name, mode_t) override;
-    virtual KResult remove_child(const StringView& name) override;
-    virtual KResult chmod(mode_t) override;
-    virtual KResult chown(UserID, GroupID) override;
-    virtual KResult truncate(u64) override;
-    virtual KResult set_atime(time_t) override;
-    virtual KResult set_ctime(time_t) override;
-    virtual KResult set_mtime(time_t) override;
+    virtual ErrorOr<void> traverse_as_directory(Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
+    virtual ErrorOr<void> flush_metadata() override;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
+    virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
+    virtual ErrorOr<void> add_child(Inode&, const StringView& name, mode_t) override;
+    virtual ErrorOr<void> remove_child(const StringView& name) override;
+    virtual ErrorOr<void> chmod(mode_t) override;
+    virtual ErrorOr<void> chown(UserID, GroupID) override;
+    virtual ErrorOr<void> truncate(u64) override;
+    virtual ErrorOr<void> set_atime(time_t) override;
+    virtual ErrorOr<void> set_ctime(time_t) override;
+    virtual ErrorOr<void> set_mtime(time_t) override;
     virtual void one_ref_left() override;
 
 private:
     TmpFSInode(TmpFS& fs, const InodeMetadata& metadata, InodeIdentifier parent);
-    static KResultOr<NonnullRefPtr<TmpFSInode>> try_create(TmpFS&, InodeMetadata const& metadata, InodeIdentifier parent);
-    static KResultOr<NonnullRefPtr<TmpFSInode>> try_create_root(TmpFS&);
+    static ErrorOr<NonnullRefPtr<TmpFSInode>> try_create(TmpFS&, InodeMetadata const& metadata, InodeIdentifier parent);
+    static ErrorOr<NonnullRefPtr<TmpFSInode>> try_create_root(TmpFS&);
     void notify_watchers();
 
     struct Child {
diff --git a/Kernel/FileSystem/VirtualFileSystem.cpp b/Kernel/FileSystem/VirtualFileSystem.cpp
index b7c8d908266..319cb91d9c0 100644
--- a/Kernel/FileSystem/VirtualFileSystem.cpp
+++ b/Kernel/FileSystem/VirtualFileSystem.cpp
@@ -51,9 +51,9 @@ InodeIdentifier VirtualFileSystem::root_inode_id() const
     return m_root_inode->identifier();
 }
 
-KResult VirtualFileSystem::mount(FileSystem& fs, Custody& mount_point, int flags)
+ErrorOr<void> VirtualFileSystem::mount(FileSystem& fs, Custody& mount_point, int flags)
 {
-    return m_mounts.with_exclusive([&](auto& mounts) -> KResult {
+    return m_mounts.with_exclusive([&](auto& mounts) -> ErrorOr<void> {
         auto& inode = mount_point.inode();
         dbgln("VirtualFileSystem: Mounting {} at inode {} with flags {}",
             fs.class_name(),
@@ -62,22 +62,22 @@ KResult VirtualFileSystem::mount(FileSystem& fs, Custody& mount_point, int flags
         // FIXME: check that this is not already a mount point
         Mount mount { fs, &mount_point, flags };
         mounts.append(move(mount));
-        return KSuccess;
+        return {};
     });
 }
 
-KResult VirtualFileSystem::bind_mount(Custody& source, Custody& mount_point, int flags)
+ErrorOr<void> VirtualFileSystem::bind_mount(Custody& source, Custody& mount_point, int flags)
 {
-    return m_mounts.with_exclusive([&](auto& mounts) -> KResult {
+    return m_mounts.with_exclusive([&](auto& mounts) -> ErrorOr<void> {
         dbgln("VirtualFileSystem: Bind-mounting inode {} at inode {}", source.inode().identifier(), mount_point.inode().identifier());
         // FIXME: check that this is not already a mount point
         Mount mount { source.inode(), mount_point, flags };
         mounts.append(move(mount));
-        return KSuccess;
+        return {};
     });
 }
 
-KResult VirtualFileSystem::remount(Custody& mount_point, int new_flags)
+ErrorOr<void> VirtualFileSystem::remount(Custody& mount_point, int new_flags)
 {
     dbgln("VirtualFileSystem: Remounting inode {}", mount_point.inode().identifier());
 
@@ -86,14 +86,14 @@ KResult VirtualFileSystem::remount(Custody& mount_point, int new_flags)
         return ENODEV;
 
     mount->set_flags(new_flags);
-    return KSuccess;
+    return {};
 }
 
-KResult VirtualFileSystem::unmount(Inode& guest_inode)
+ErrorOr<void> VirtualFileSystem::unmount(Inode& guest_inode)
 {
     dbgln("VirtualFileSystem: unmount called with inode {}", guest_inode.identifier());
 
-    return m_mounts.with_exclusive([&](auto& mounts) -> KResult {
+    return m_mounts.with_exclusive([&](auto& mounts) -> ErrorOr<void> {
         for (size_t i = 0; i < mounts.size(); ++i) {
             auto& mount = mounts[i];
             if (&mount.guest() != &guest_inode)
@@ -101,14 +101,14 @@ KResult VirtualFileSystem::unmount(Inode& guest_inode)
             TRY(mount.guest_fs().prepare_to_unmount());
             dbgln("VirtualFileSystem: Unmounting file system {}...", mount.guest_fs().fsid());
             mounts.unstable_take(i);
-            return KSuccess;
+            return {};
         }
         dbgln("VirtualFileSystem: Nothing mounted on inode {}", guest_inode.identifier());
         return ENODEV;
     });
 }
 
-KResult VirtualFileSystem::mount_root(FileSystem& fs)
+ErrorOr<void> VirtualFileSystem::mount_root(FileSystem& fs)
 {
     if (m_root_inode) {
         dmesgln("VirtualFileSystem: mount_root can't mount another root");
@@ -132,7 +132,7 @@ KResult VirtualFileSystem::mount_root(FileSystem& fs)
     });
 
     m_root_custody = TRY(Custody::try_create(nullptr, "", *m_root_inode, root_mount_flags));
-    return KSuccess;
+    return {};
 }
 
 auto VirtualFileSystem::find_mount_for_host(InodeIdentifier id) -> Mount*
@@ -162,7 +162,7 @@ bool VirtualFileSystem::is_vfs_root(InodeIdentifier inode) const
     return inode == root_inode_id();
 }
 
-KResult VirtualFileSystem::traverse_directory_inode(Inode& dir_inode, Function<bool(FileSystem::DirectoryEntryView const&)> callback)
+ErrorOr<void> VirtualFileSystem::traverse_directory_inode(Inode& dir_inode, Function<bool(FileSystem::DirectoryEntryView const&)> callback)
 {
     return dir_inode.traverse_as_directory([&](auto& entry) {
         InodeIdentifier resolved_inode;
@@ -184,7 +184,7 @@ KResult VirtualFileSystem::traverse_directory_inode(Inode& dir_inode, Function<b
     });
 }
 
-KResult VirtualFileSystem::utime(StringView path, Custody& base, time_t atime, time_t mtime)
+ErrorOr<void> VirtualFileSystem::utime(StringView path, Custody& base, time_t atime, time_t mtime)
 {
     auto custody = TRY(resolve_path(path, base));
     auto& inode = custody->inode();
@@ -196,16 +196,16 @@ KResult VirtualFileSystem::utime(StringView path, Custody& base, time_t atime, t
 
     TRY(inode.set_atime(atime));
     TRY(inode.set_mtime(mtime));
-    return KSuccess;
+    return {};
 }
 
-KResultOr<InodeMetadata> VirtualFileSystem::lookup_metadata(StringView path, Custody& base, int options)
+ErrorOr<InodeMetadata> VirtualFileSystem::lookup_metadata(StringView path, Custody& base, int options)
 {
     auto custody = TRY(resolve_path(path, base, nullptr, options));
     return custody->inode().metadata();
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> owner)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> owner)
 {
     if ((options & O_CREAT) && (options & O_DIRECTORY))
         return EINVAL;
@@ -215,9 +215,9 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::open(StringView
     if (custody_or_error.is_error()) {
         // NOTE: ENOENT with a non-null parent custody signals us that the immediate parent
         //       of the file exists, but the file itself does not.
-        if ((options & O_CREAT) && custody_or_error.error() == ENOENT && parent_custody)
+        if ((options & O_CREAT) && custody_or_error.error().code() == ENOENT && parent_custody)
             return create(path, options, mode, *parent_custody, move(owner));
-        return custody_or_error.error();
+        return custody_or_error.release_error();
     }
 
     if ((options & O_CREAT) && (options & O_EXCL))
@@ -297,7 +297,7 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::open(StringView
     return description;
 }
 
-KResult VirtualFileSystem::mknod(StringView path, mode_t mode, dev_t dev, Custody& base)
+ErrorOr<void> VirtualFileSystem::mknod(StringView path, mode_t mode, dev_t dev, Custody& base)
 {
     if (!is_regular_file(mode) && !is_block_device(mode) && !is_character_device(mode) && !is_fifo(mode) && !is_socket(mode))
         return EINVAL;
@@ -308,8 +308,8 @@ KResult VirtualFileSystem::mknod(StringView path, mode_t mode, dev_t dev, Custod
         return EEXIST;
     if (!parent_custody)
         return ENOENT;
-    if (existing_file_or_error.error() != ENOENT)
-        return existing_file_or_error.error();
+    if (existing_file_or_error.error().code() != ENOENT)
+        return existing_file_or_error.release_error();
     auto& parent_inode = parent_custody->inode();
     auto& current_process = Process::current();
     if (!parent_inode.metadata().may_write(current_process))
@@ -319,10 +319,11 @@ KResult VirtualFileSystem::mknod(StringView path, mode_t mode, dev_t dev, Custod
 
     auto basename = KLexicalPath::basename(path);
     dbgln_if(VFS_DEBUG, "VirtualFileSystem::mknod: '{}' mode={} dev={} in {}", basename, mode, dev, parent_inode.identifier());
-    return parent_inode.create_child(basename, mode, dev, current_process.euid(), current_process.egid()).result();
+    TRY(parent_inode.create_child(basename, mode, dev, current_process.euid(), current_process.egid()));
+    return {};
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> owner)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> owner)
 {
     auto basename = KLexicalPath::basename(path);
     auto parent_path = TRY(parent_custody.try_serialize_absolute_path());
@@ -354,7 +355,7 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> VirtualFileSystem::create(StringVi
     return description;
 }
 
-KResult VirtualFileSystem::mkdir(StringView path, mode_t mode, Custody& base)
+ErrorOr<void> VirtualFileSystem::mkdir(StringView path, mode_t mode, Custody& base)
 {
     // Unlike in basically every other case, where it's only the last
     // path component (the one being created) that is allowed not to
@@ -371,9 +372,9 @@ KResult VirtualFileSystem::mkdir(StringView path, mode_t mode, Custody& base)
     if (!result.is_error())
         return EEXIST;
     else if (!parent_custody)
-        return result.error();
+        return result.release_error();
     // NOTE: If resolve_path fails with a non-null parent custody, the error should be ENOENT.
-    VERIFY(result.error() == ENOENT);
+    VERIFY(result.error().code() == ENOENT);
 
     auto& parent_inode = parent_custody->inode();
     auto& current_process = Process::current();
@@ -384,10 +385,11 @@ KResult VirtualFileSystem::mkdir(StringView path, mode_t mode, Custody& base)
 
     auto basename = KLexicalPath::basename(path);
     dbgln_if(VFS_DEBUG, "VirtualFileSystem::mkdir: '{}' in {}", basename, parent_inode.identifier());
-    return parent_inode.create_child(basename, S_IFDIR | mode, 0, current_process.euid(), current_process.egid()).result();
+    TRY(parent_inode.create_child(basename, S_IFDIR | mode, 0, current_process.euid(), current_process.egid()));
+    return {};
 }
 
-KResult VirtualFileSystem::access(StringView path, int mode, Custody& base)
+ErrorOr<void> VirtualFileSystem::access(StringView path, int mode, Custody& base)
 {
     auto custody = TRY(resolve_path(path, base));
 
@@ -408,10 +410,10 @@ KResult VirtualFileSystem::access(StringView path, int mode, Custody& base)
         if (!metadata.may_execute(current_process))
             return EACCES;
     }
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Custody>> VirtualFileSystem::open_directory(StringView path, Custody& base)
+ErrorOr<NonnullRefPtr<Custody>> VirtualFileSystem::open_directory(StringView path, Custody& base)
 {
     auto custody = TRY(resolve_path(path, base));
     auto& inode = custody->inode();
@@ -422,7 +424,7 @@ KResultOr<NonnullRefPtr<Custody>> VirtualFileSystem::open_directory(StringView p
     return custody;
 }
 
-KResult VirtualFileSystem::chmod(Custody& custody, mode_t mode)
+ErrorOr<void> VirtualFileSystem::chmod(Custody& custody, mode_t mode)
 {
     auto& inode = custody.inode();
 
@@ -437,13 +439,13 @@ KResult VirtualFileSystem::chmod(Custody& custody, mode_t mode)
     return inode.chmod(mode);
 }
 
-KResult VirtualFileSystem::chmod(StringView path, mode_t mode, Custody& base)
+ErrorOr<void> VirtualFileSystem::chmod(StringView path, mode_t mode, Custody& base)
 {
     auto custody = TRY(resolve_path(path, base));
     return chmod(custody, mode);
 }
 
-KResult VirtualFileSystem::rename(StringView old_path, StringView new_path, Custody& base)
+ErrorOr<void> VirtualFileSystem::rename(StringView old_path, StringView new_path, Custody& base)
 {
     RefPtr<Custody> old_parent_custody;
     auto old_custody = TRY(resolve_path(old_path, base, &old_parent_custody, O_NOFOLLOW_NOERROR));
@@ -452,8 +454,8 @@ KResult VirtualFileSystem::rename(StringView old_path, StringView new_path, Cust
     RefPtr<Custody> new_parent_custody;
     auto new_custody_or_error = resolve_path(new_path, base, &new_parent_custody);
     if (new_custody_or_error.is_error()) {
-        if (new_custody_or_error.error() != ENOENT || !new_parent_custody)
-            return new_custody_or_error.error();
+        if (new_custody_or_error.error().code() != ENOENT || !new_parent_custody)
+            return new_custody_or_error.release_error();
     }
 
     if (!old_parent_custody || !new_parent_custody) {
@@ -509,14 +511,14 @@ KResult VirtualFileSystem::rename(StringView old_path, StringView new_path, Cust
         return EINVAL;
 
     if (old_basename == new_basename && old_parent_inode.index() == new_parent_inode.index())
-        return KSuccess;
+        return {};
 
     if (!new_custody_or_error.is_error()) {
         auto& new_custody = *new_custody_or_error.value();
         auto& new_inode = new_custody.inode();
         // FIXME: Is this really correct? Check what other systems do.
         if (&new_inode == &old_inode)
-            return KSuccess;
+            return {};
         if (new_parent_inode.metadata().is_sticky()) {
             if (!current_process.is_superuser() && new_inode.metadata().uid != current_process.euid())
                 return EACCES;
@@ -528,10 +530,10 @@ KResult VirtualFileSystem::rename(StringView old_path, StringView new_path, Cust
 
     TRY(new_parent_inode.add_child(old_inode, new_basename, old_inode.mode()));
     TRY(old_parent_inode.remove_child(old_basename));
-    return KSuccess;
+    return {};
 }
 
-KResult VirtualFileSystem::chown(Custody& custody, UserID a_uid, GroupID a_gid)
+ErrorOr<void> VirtualFileSystem::chown(Custody& custody, UserID a_uid, GroupID a_gid)
 {
     auto& inode = custody.inode();
     auto metadata = inode.metadata();
@@ -567,7 +569,7 @@ KResult VirtualFileSystem::chown(Custody& custody, UserID a_uid, GroupID a_gid)
     return inode.chown(new_uid, new_gid);
 }
 
-KResult VirtualFileSystem::chown(StringView path, UserID a_uid, GroupID a_gid, Custody& base)
+ErrorOr<void> VirtualFileSystem::chown(StringView path, UserID a_uid, GroupID a_gid, Custody& base)
 {
     auto custody = TRY(resolve_path(path, base));
     return chown(custody, a_uid, a_gid);
@@ -590,7 +592,7 @@ static bool hard_link_allowed(const Inode& inode)
     return false;
 }
 
-KResult VirtualFileSystem::link(StringView old_path, StringView new_path, Custody& base)
+ErrorOr<void> VirtualFileSystem::link(StringView old_path, StringView new_path, Custody& base)
 {
     auto old_custody = TRY(resolve_path(old_path, base));
     auto& old_inode = old_custody->inode();
@@ -623,7 +625,7 @@ KResult VirtualFileSystem::link(StringView old_path, StringView new_path, Custod
     return parent_inode.add_child(old_inode, KLexicalPath::basename(new_path), old_inode.mode());
 }
 
-KResult VirtualFileSystem::unlink(StringView path, Custody& base)
+ErrorOr<void> VirtualFileSystem::unlink(StringView path, Custody& base)
 {
     RefPtr<Custody> parent_custody;
     auto custody = TRY(resolve_path(path, base, &parent_custody, O_NOFOLLOW_NOERROR | O_UNLINK_INTERNAL));
@@ -653,7 +655,7 @@ KResult VirtualFileSystem::unlink(StringView path, Custody& base)
     return parent_inode.remove_child(KLexicalPath::basename(path));
 }
 
-KResult VirtualFileSystem::symlink(StringView target, StringView linkpath, Custody& base)
+ErrorOr<void> VirtualFileSystem::symlink(StringView target, StringView linkpath, Custody& base)
 {
     RefPtr<Custody> parent_custody;
     auto existing_custody_or_error = resolve_path(linkpath, base, &parent_custody);
@@ -661,8 +663,8 @@ KResult VirtualFileSystem::symlink(StringView target, StringView linkpath, Custo
         return EEXIST;
     if (!parent_custody)
         return ENOENT;
-    if (existing_custody_or_error.is_error() && existing_custody_or_error.error() != ENOENT)
-        return existing_custody_or_error.error();
+    if (existing_custody_or_error.is_error() && existing_custody_or_error.error().code() != ENOENT)
+        return existing_custody_or_error.release_error();
     auto& parent_inode = parent_custody->inode();
     auto& current_process = Process::current();
     if (!parent_inode.metadata().may_write(current_process))
@@ -677,10 +679,10 @@ KResult VirtualFileSystem::symlink(StringView target, StringView linkpath, Custo
 
     auto target_buffer = UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>((const u8*)target.characters_without_null_termination()));
     TRY(inode->write_bytes(0, target.length(), target_buffer, nullptr));
-    return KSuccess;
+    return {};
 }
 
-KResult VirtualFileSystem::rmdir(StringView path, Custody& base)
+ErrorOr<void> VirtualFileSystem::rmdir(StringView path, Custody& base)
 {
     RefPtr<Custody> parent_custody;
     auto custody = TRY(resolve_path(path, base, &parent_custody));
@@ -755,20 +757,20 @@ UnveilNode const& VirtualFileSystem::find_matching_unveiled_path(StringView path
     return unveil_root.traverse_until_last_accessible_node(path_parts.begin(), path_parts.end());
 }
 
-KResult VirtualFileSystem::validate_path_against_process_veil(Custody const& custody, int options)
+ErrorOr<void> VirtualFileSystem::validate_path_against_process_veil(Custody const& custody, int options)
 {
     if (Process::current().veil_state() == VeilState::None)
-        return KSuccess;
+        return {};
     auto absolute_path = TRY(custody.try_serialize_absolute_path());
     return validate_path_against_process_veil(absolute_path->view(), options);
 }
 
-KResult VirtualFileSystem::validate_path_against_process_veil(StringView path, int options)
+ErrorOr<void> VirtualFileSystem::validate_path_against_process_veil(StringView path, int options)
 {
     if (Process::current().veil_state() == VeilState::None)
-        return KSuccess;
+        return {};
     if (options == O_EXEC && path == "/usr/lib/Loader.so")
-        return KSuccess;
+        return {};
 
     VERIFY(path.starts_with('/'));
     VERIFY(!path.contains("/../"sv) && !path.ends_with("/.."sv));
@@ -794,7 +796,7 @@ KResult VirtualFileSystem::validate_path_against_process_veil(StringView path, i
             dump_backtrace();
             return EACCES;
         }
-        return KSuccess;
+        return {};
     }
     if (options & O_RDONLY) {
         if (options & O_DIRECTORY) {
@@ -825,10 +827,10 @@ KResult VirtualFileSystem::validate_path_against_process_veil(StringView path, i
             return EACCES;
         }
     }
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Custody>> VirtualFileSystem::resolve_path(StringView path, Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level)
+ErrorOr<NonnullRefPtr<Custody>> VirtualFileSystem::resolve_path(StringView path, Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level)
 {
     auto custody = TRY(resolve_path_without_veil(path, base, out_parent, options, symlink_recursion_level));
     TRY(validate_path_against_process_veil(*custody, options));
@@ -850,7 +852,7 @@ static bool safe_to_follow_symlink(const Inode& inode, const InodeMetadata& pare
     return false;
 }
 
-KResultOr<NonnullRefPtr<Custody>> VirtualFileSystem::resolve_path_without_veil(StringView path, Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level)
+ErrorOr<NonnullRefPtr<Custody>> VirtualFileSystem::resolve_path_without_veil(StringView path, Custody& base, RefPtr<Custody>* out_parent, int options, int symlink_recursion_level)
 {
     if (symlink_recursion_level >= symlink_recursion_limit)
         return ELOOP;
@@ -898,7 +900,7 @@ KResultOr<NonnullRefPtr<Custody>> VirtualFileSystem::resolve_path_without_veil(S
                 // does not exist yet.
                 *out_parent = have_more_parts ? nullptr : &parent;
             }
-            return child_or_error.error();
+            return child_or_error.release_error();
         }
         auto child_inode = child_or_error.release_value();
 
diff --git a/Kernel/FileSystem/VirtualFileSystem.h b/Kernel/FileSystem/VirtualFileSystem.h
index 09b4fd05de9..bbf2d77ec0c 100644
--- a/Kernel/FileSystem/VirtualFileSystem.h
+++ b/Kernel/FileSystem/VirtualFileSystem.h
@@ -7,13 +7,13 @@
 #pragma once
 
 #include <AK/Badge.h>
+#include <AK/Error.h>
 #include <AK/Function.h>
 #include <AK/HashMap.h>
 #include <AK/NonnullOwnPtrVector.h>
 #include <AK/OwnPtr.h>
 #include <AK/RefPtr.h>
 #include <AK/String.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/FileSystem.h>
 #include <Kernel/FileSystem/InodeIdentifier.h>
 #include <Kernel/FileSystem/InodeMetadata.h>
@@ -42,29 +42,29 @@ public:
     VirtualFileSystem();
     ~VirtualFileSystem();
 
-    KResult mount_root(FileSystem&);
-    KResult mount(FileSystem&, Custody& mount_point, int flags);
-    KResult bind_mount(Custody& source, Custody& mount_point, int flags);
-    KResult remount(Custody& mount_point, int new_flags);
-    KResult unmount(Inode& guest_inode);
+    ErrorOr<void> mount_root(FileSystem&);
+    ErrorOr<void> mount(FileSystem&, Custody& mount_point, int flags);
+    ErrorOr<void> bind_mount(Custody& source, Custody& mount_point, int flags);
+    ErrorOr<void> remount(Custody& mount_point, int new_flags);
+    ErrorOr<void> unmount(Inode& guest_inode);
 
-    KResultOr<NonnullRefPtr<OpenFileDescription>> open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> = {});
-    KResultOr<NonnullRefPtr<OpenFileDescription>> create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> = {});
-    KResult mkdir(StringView path, mode_t mode, Custody& base);
-    KResult link(StringView old_path, StringView new_path, Custody& base);
-    KResult unlink(StringView path, Custody& base);
-    KResult symlink(StringView target, StringView linkpath, Custody& base);
-    KResult rmdir(StringView path, Custody& base);
-    KResult chmod(StringView path, mode_t, Custody& base);
-    KResult chmod(Custody&, mode_t);
-    KResult chown(StringView path, UserID, GroupID, Custody& base);
-    KResult chown(Custody&, UserID, GroupID);
-    KResult access(StringView path, int mode, Custody& base);
-    KResultOr<InodeMetadata> lookup_metadata(StringView path, Custody& base, int options = 0);
-    KResult utime(StringView path, Custody& base, time_t atime, time_t mtime);
-    KResult rename(StringView oldpath, StringView newpath, Custody& base);
-    KResult mknod(StringView path, mode_t, dev_t, Custody& base);
-    KResultOr<NonnullRefPtr<Custody>> open_directory(StringView path, Custody& base);
+    ErrorOr<NonnullRefPtr<OpenFileDescription>> open(StringView path, int options, mode_t mode, Custody& base, Optional<UidAndGid> = {});
+    ErrorOr<NonnullRefPtr<OpenFileDescription>> create(StringView path, int options, mode_t mode, Custody& parent_custody, Optional<UidAndGid> = {});
+    ErrorOr<void> mkdir(StringView path, mode_t mode, Custody& base);
+    ErrorOr<void> link(StringView old_path, StringView new_path, Custody& base);
+    ErrorOr<void> unlink(StringView path, Custody& base);
+    ErrorOr<void> symlink(StringView target, StringView linkpath, Custody& base);
+    ErrorOr<void> rmdir(StringView path, Custody& base);
+    ErrorOr<void> chmod(StringView path, mode_t, Custody& base);
+    ErrorOr<void> chmod(Custody&, mode_t);
+    ErrorOr<void> chown(StringView path, UserID, GroupID, Custody& base);
+    ErrorOr<void> chown(Custody&, UserID, GroupID);
+    ErrorOr<void> access(StringView path, int mode, Custody& base);
+    ErrorOr<InodeMetadata> lookup_metadata(StringView path, Custody& base, int options = 0);
+    ErrorOr<void> utime(StringView path, Custody& base, time_t atime, time_t mtime);
+    ErrorOr<void> rename(StringView oldpath, StringView newpath, Custody& base);
+    ErrorOr<void> mknod(StringView path, mode_t, dev_t, Custody& base);
+    ErrorOr<NonnullRefPtr<Custody>> open_directory(StringView path, Custody& base);
 
     void for_each_mount(Function<IterationDecision(const Mount&)>) const;
 
@@ -73,19 +73,19 @@ public:
     static void sync();
 
     Custody& root_custody();
-    KResultOr<NonnullRefPtr<Custody>> resolve_path(StringView path, Custody& base, RefPtr<Custody>* out_parent = nullptr, int options = 0, int symlink_recursion_level = 0);
-    KResultOr<NonnullRefPtr<Custody>> resolve_path_without_veil(StringView path, Custody& base, RefPtr<Custody>* out_parent = nullptr, int options = 0, int symlink_recursion_level = 0);
+    ErrorOr<NonnullRefPtr<Custody>> resolve_path(StringView path, Custody& base, RefPtr<Custody>* out_parent = nullptr, int options = 0, int symlink_recursion_level = 0);
+    ErrorOr<NonnullRefPtr<Custody>> resolve_path_without_veil(StringView path, Custody& base, RefPtr<Custody>* out_parent = nullptr, int options = 0, int symlink_recursion_level = 0);
 
 private:
     friend class OpenFileDescription;
 
     UnveilNode const& find_matching_unveiled_path(StringView path);
-    KResult validate_path_against_process_veil(Custody const& path, int options);
-    KResult validate_path_against_process_veil(StringView path, int options);
+    ErrorOr<void> validate_path_against_process_veil(Custody const& path, int options);
+    ErrorOr<void> validate_path_against_process_veil(StringView path, int options);
 
     bool is_vfs_root(InodeIdentifier) const;
 
-    KResult traverse_directory_inode(Inode&, Function<bool(FileSystem::DirectoryEntryView const&)>);
+    ErrorOr<void> traverse_directory_inode(Inode&, Function<bool(FileSystem::DirectoryEntryView const&)>);
 
     Mount* find_mount_for_host(InodeIdentifier);
     Mount* find_mount_for_guest(InodeIdentifier);
diff --git a/Kernel/Firmware/ACPI/Parser.cpp b/Kernel/Firmware/ACPI/Parser.cpp
index 7d6a632b40f..ef19a8661c8 100644
--- a/Kernel/Firmware/ACPI/Parser.cpp
+++ b/Kernel/Firmware/ACPI/Parser.cpp
@@ -39,19 +39,19 @@ UNMAP_AFTER_INIT NonnullRefPtr<ACPISysFSComponent> ACPISysFSComponent::create(St
     return adopt_ref(*new (nothrow) ACPISysFSComponent(name, paddr, table_size));
 }
 
-KResultOr<size_t> ACPISysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> ACPISysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     auto blob = TRY(try_to_generate_buffer());
 
     if ((size_t)offset >= blob->size())
-        return KSuccess;
+        return 0;
 
     ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
     TRY(buffer.write(blob->data() + offset, nread));
     return nread;
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> ACPISysFSComponent::try_to_generate_buffer() const
+ErrorOr<NonnullOwnPtr<KBuffer>> ACPISysFSComponent::try_to_generate_buffer() const
 {
     auto acpi_blob = Memory::map_typed<u8>((m_paddr), m_length);
     return KBuffer::try_create_with_bytes(Span<u8> { acpi_blob.ptr(), m_length });
@@ -64,7 +64,7 @@ UNMAP_AFTER_INIT ACPISysFSComponent::ACPISysFSComponent(String name, PhysicalAdd
 {
 }
 
-UNMAP_AFTER_INIT KResultOr<NonnullRefPtr<ACPISysFSDirectory>> ACPISysFSDirectory::try_create(FirmwareSysFSDirectory& firmware_directory)
+UNMAP_AFTER_INIT ErrorOr<NonnullRefPtr<ACPISysFSDirectory>> ACPISysFSDirectory::try_create(FirmwareSysFSDirectory& firmware_directory)
 {
     auto acpi_directory = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) ACPISysFSDirectory(firmware_directory)));
     return acpi_directory;
diff --git a/Kernel/Firmware/ACPI/Parser.h b/Kernel/Firmware/ACPI/Parser.h
index 9c11b2100b1..903d6d5b495 100644
--- a/Kernel/Firmware/ACPI/Parser.h
+++ b/Kernel/Firmware/ACPI/Parser.h
@@ -22,7 +22,7 @@ namespace Kernel::ACPI {
 
 class ACPISysFSDirectory : public SysFSDirectory {
 public:
-    static KResultOr<NonnullRefPtr<ACPISysFSDirectory>> try_create(FirmwareSysFSDirectory& firmware_directory);
+    static ErrorOr<NonnullRefPtr<ACPISysFSDirectory>> try_create(FirmwareSysFSDirectory& firmware_directory);
 
 private:
     explicit ACPISysFSDirectory(FirmwareSysFSDirectory& firmware_directory);
@@ -32,10 +32,10 @@ class ACPISysFSComponent : public SysFSComponent {
 public:
     static NonnullRefPtr<ACPISysFSComponent> create(String name, PhysicalAddress, size_t table_size);
 
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
 
 protected:
-    KResultOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const;
+    ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const;
     ACPISysFSComponent(String name, PhysicalAddress, size_t table_size);
 
     PhysicalAddress m_paddr;
diff --git a/Kernel/Firmware/BIOS.cpp b/Kernel/Firmware/BIOS.cpp
index 9bf9f5905c5..dd99a92b6d3 100644
--- a/Kernel/Firmware/BIOS.cpp
+++ b/Kernel/Firmware/BIOS.cpp
@@ -29,12 +29,12 @@ UNMAP_AFTER_INIT BIOSSysFSComponent::BIOSSysFSComponent(StringView name)
 {
 }
 
-KResultOr<size_t> BIOSSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> BIOSSysFSComponent::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     auto blob = TRY(try_to_generate_buffer());
 
     if ((size_t)offset >= blob->size())
-        return KSuccess;
+        return 0;
 
     ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
     TRY(buffer.write(blob->data() + offset, nread));
@@ -48,7 +48,7 @@ UNMAP_AFTER_INIT DMIEntryPointExposedBlob::DMIEntryPointExposedBlob(PhysicalAddr
 {
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> DMIEntryPointExposedBlob::try_to_generate_buffer() const
+ErrorOr<NonnullOwnPtr<KBuffer>> DMIEntryPointExposedBlob::try_to_generate_buffer() const
 {
     auto dmi_blob = Memory::map_typed<u8>((m_dmi_entry_point), m_dmi_entry_point_length);
     return KBuffer::try_create_with_bytes(Span<u8> { dmi_blob.ptr(), m_dmi_entry_point_length });
@@ -66,7 +66,7 @@ UNMAP_AFTER_INIT SMBIOSExposedTable::SMBIOSExposedTable(PhysicalAddress smbios_s
 {
 }
 
-KResultOr<NonnullOwnPtr<KBuffer>> SMBIOSExposedTable::try_to_generate_buffer() const
+ErrorOr<NonnullOwnPtr<KBuffer>> SMBIOSExposedTable::try_to_generate_buffer() const
 {
     auto dmi_blob = Memory::map_typed<u8>((m_smbios_structure_table), m_smbios_structure_table_length);
     return KBuffer::try_create_with_bytes(Span<u8> { dmi_blob.ptr(), m_smbios_structure_table_length });
@@ -90,7 +90,7 @@ UNMAP_AFTER_INIT void BIOSSysFSDirectory::set_dmi_32_bit_entry_initialization_va
     m_smbios_structure_table_length = smbios_entry.ptr()->legacy_structure.smboios_table_length;
 }
 
-UNMAP_AFTER_INIT KResultOr<NonnullRefPtr<BIOSSysFSDirectory>> BIOSSysFSDirectory::try_create(FirmwareSysFSDirectory& firmware_directory)
+UNMAP_AFTER_INIT ErrorOr<NonnullRefPtr<BIOSSysFSDirectory>> BIOSSysFSDirectory::try_create(FirmwareSysFSDirectory& firmware_directory)
 {
     auto bios_directory = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) BIOSSysFSDirectory(firmware_directory)));
     bios_directory->create_components();
diff --git a/Kernel/Firmware/BIOS.h b/Kernel/Firmware/BIOS.h
index 8766d4a7962..55618393f8b 100644
--- a/Kernel/Firmware/BIOS.h
+++ b/Kernel/Firmware/BIOS.h
@@ -62,10 +62,10 @@ Memory::MappedROM map_ebda();
 
 class BIOSSysFSComponent : public SysFSComponent {
 public:
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const override;
 
 protected:
-    virtual KResultOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const = 0;
+    virtual ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const = 0;
     explicit BIOSSysFSComponent(StringView name);
 };
 
@@ -75,7 +75,7 @@ public:
 
 private:
     DMIEntryPointExposedBlob(PhysicalAddress dmi_entry_point, size_t blob_size);
-    virtual KResultOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const override;
+    virtual ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const override;
     PhysicalAddress m_dmi_entry_point;
     size_t m_dmi_entry_point_length;
 };
@@ -86,7 +86,7 @@ public:
 
 private:
     SMBIOSExposedTable(PhysicalAddress dmi_entry_point, size_t blob_size);
-    virtual KResultOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const override;
+    virtual ErrorOr<NonnullOwnPtr<KBuffer>> try_to_generate_buffer() const override;
 
     PhysicalAddress m_smbios_structure_table;
     size_t m_smbios_structure_table_length;
@@ -94,7 +94,7 @@ private:
 
 class BIOSSysFSDirectory : public SysFSDirectory {
 public:
-    static KResultOr<NonnullRefPtr<BIOSSysFSDirectory>> try_create(FirmwareSysFSDirectory&);
+    static ErrorOr<NonnullRefPtr<BIOSSysFSDirectory>> try_create(FirmwareSysFSDirectory&);
 
     void create_components();
 
diff --git a/Kernel/Firmware/PowerStateSwitch.cpp b/Kernel/Firmware/PowerStateSwitch.cpp
index e0f9b53dbea..f76b415f07c 100644
--- a/Kernel/Firmware/PowerStateSwitch.cpp
+++ b/Kernel/Firmware/PowerStateSwitch.cpp
@@ -30,16 +30,16 @@ UNMAP_AFTER_INIT PowerStateSwitchNode::PowerStateSwitchNode(FirmwareSysFSDirecto
 {
 }
 
-KResult PowerStateSwitchNode::truncate(u64 size)
+ErrorOr<void> PowerStateSwitchNode::truncate(u64 size)
 {
     // Note: This node doesn't store any useful data anyway, so we can safely
     // truncate this to zero (essentially ignoring the request without failing).
     if (size != 0)
         return EPERM;
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> PowerStateSwitchNode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& data, OpenFileDescription*)
+ErrorOr<size_t> PowerStateSwitchNode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& data, OpenFileDescription*)
 {
     if (Checked<off_t>::addition_would_overflow(offset, count))
         return EOVERFLOW;
diff --git a/Kernel/Firmware/PowerStateSwitch.h b/Kernel/Firmware/PowerStateSwitch.h
index c35bd85ff43..e02db5138fd 100644
--- a/Kernel/Firmware/PowerStateSwitch.h
+++ b/Kernel/Firmware/PowerStateSwitch.h
@@ -24,9 +24,9 @@ class PowerStateSwitchNode final : public SysFSComponent {
 public:
     static NonnullRefPtr<PowerStateSwitchNode> must_create(FirmwareSysFSDirectory&);
     virtual mode_t permissions() const override;
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) override;
-    virtual KResult truncate(u64) override;
-    virtual KResult set_mtime(time_t) { return KSuccess; }
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*) override;
+    virtual ErrorOr<void> truncate(u64) override;
+    virtual ErrorOr<void> set_mtime(time_t) { return {}; }
 
 private:
     PowerStateSwitchNode(FirmwareSysFSDirectory&);
diff --git a/Kernel/Forward.h b/Kernel/Forward.h
index 302b5f635ba..f80ca4d5ec9 100644
--- a/Kernel/Forward.h
+++ b/Kernel/Forward.h
@@ -32,7 +32,6 @@ class Inode;
 class InodeIdentifier;
 class InodeWatcher;
 class KBuffer;
-class KResult;
 class LocalSocket;
 class Mutex;
 class MasterPTY;
@@ -87,8 +86,6 @@ class VirtualRangeAllocator;
 class Spinlock;
 template<typename LockType>
 class SpinlockLocker;
-template<typename T>
-class KResultOr;
 
 struct InodeMetadata;
 struct TrapFrame;
diff --git a/Kernel/GlobalProcessExposed.cpp b/Kernel/GlobalProcessExposed.cpp
index d17d96c2f94..782a9405791 100644
--- a/Kernel/GlobalProcessExposed.cpp
+++ b/Kernel/GlobalProcessExposed.cpp
@@ -40,7 +40,7 @@ public:
 
 private:
     ProcFSAdapters();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         NetworkingManagement::the().for_each([&array](auto& adapter) {
@@ -64,7 +64,7 @@ private:
             obj.add("mtu", adapter.mtu());
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -74,7 +74,7 @@ public:
 
 private:
     ProcFSARP();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         arp_table().for_each_shared([&](const auto& it) {
@@ -83,7 +83,7 @@ private:
             obj.add("ip_address", it.key.to_string());
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -93,7 +93,7 @@ public:
 
 private:
     ProcFSTCP();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         TCPSocket::for_each([&array](auto& socket) {
@@ -116,7 +116,7 @@ private:
             }
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -126,7 +126,7 @@ public:
 
 private:
     ProcFSLocalNet();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         LocalSocket::for_each([&array](auto& socket) {
@@ -140,7 +140,7 @@ private:
             obj.add("acceptor_gid", socket.acceptor_gid().value());
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -150,7 +150,7 @@ public:
 
 private:
     ProcFSUDP();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         UDPSocket::for_each([&array](auto& socket) {
@@ -166,7 +166,7 @@ private:
             }
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -348,10 +348,10 @@ public:
 
 private:
     ProcFSDiskUsage();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
-        KResult result = KSuccess;
+        ErrorOr<void> result;
         VirtualFileSystem::the().for_each_mount([&array, &result](auto& mount) {
             auto& fs = mount.guest_fs();
             auto fs_object = array.add_object();
@@ -369,7 +369,7 @@ private:
                 auto pseudo_path_or_error = static_cast<const FileBackedFileSystem&>(fs).file_description().pseudo_path();
                 if (pseudo_path_or_error.is_error()) {
                     // We're probably out of memory and should not attempt to continue.
-                    result = pseudo_path_or_error.error();
+                    result = pseudo_path_or_error.release_error();
                     return IterationDecision::Break;
                 }
                 fs_object.add("source", pseudo_path_or_error.value()->characters());
@@ -379,7 +379,7 @@ private:
 
             return IterationDecision::Continue;
         });
-        if (result == KSuccess)
+        if (!result.is_error())
             array.finish();
         return result;
     }
@@ -391,7 +391,7 @@ public:
 
 private:
     ProcFSMemoryStatus();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         InterruptDisabler disabler;
 
@@ -418,7 +418,7 @@ private:
             json.add(String::formatted("{}_num_free", prefix), num_free);
         });
         json.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -428,7 +428,7 @@ public:
 
 private:
     ProcFSSystemStatistics();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonObjectSerializer<KBufferBuilder> json { builder };
         auto total_time_scheduled = Scheduler::get_total_time_scheduled();
@@ -441,7 +441,7 @@ private:
         });
         json.add("idle_time", idle_time);
         json.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -451,7 +451,7 @@ public:
 
 private:
     ProcFSOverallProcesses();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonObjectSerializer<KBufferBuilder> json { builder };
 
@@ -549,7 +549,7 @@ private:
             json.add("total_time", total_time_scheduled.total);
             json.add("total_time_kernel", total_time_scheduled.total_kernel);
         }
-        return KSuccess;
+        return {};
     }
 };
 class ProcFSCPUInformation final : public ProcFSGlobalInformation {
@@ -558,7 +558,7 @@ public:
 
 private:
     ProcFSCPUInformation();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         Processor::for_each(
@@ -580,7 +580,7 @@ private:
                 obj.add("brandstr", info.brandstr());
             });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 class ProcFSDmesg final : public ProcFSGlobalInformation {
@@ -591,14 +591,14 @@ public:
 
 private:
     ProcFSDmesg();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         VERIFY(DeviceManagement::the().is_console_device_attached());
         InterruptDisabler disabler;
         for (char ch : DeviceManagement::the().console_device().logbuffer()) {
             TRY(builder.append(ch));
         }
-        return KSuccess;
+        return {};
     }
 };
 class ProcFSInterrupts final : public ProcFSGlobalInformation {
@@ -607,7 +607,7 @@ public:
 
 private:
     ProcFSInterrupts();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         InterruptManagement::the().enumerate_interrupt_handlers([&array](GenericInterruptHandler& handler) {
@@ -620,7 +620,7 @@ private:
             obj.add("call_count", (unsigned)handler.get_invoking_count());
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 class ProcFSKeymap final : public ProcFSGlobalInformation {
@@ -629,12 +629,12 @@ public:
 
 private:
     ProcFSKeymap();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonObjectSerializer<KBufferBuilder> json { builder };
         json.add("keymap", HIDManagement::the().keymap_name());
         json.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -645,7 +645,7 @@ public:
 
 private:
     ProcFSPCI();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         PCI::enumerate([&array](PCI::DeviceIdentifier const& device_identifier) {
@@ -663,7 +663,7 @@ private:
             obj.add("subsystem_vendor_id", device_identifier.subsystem_vendor_id().value());
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 
@@ -673,7 +673,7 @@ public:
 
 private:
     ProcFSDevices();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         JsonArraySerializer array { builder };
         DeviceManagement::the().for_each([&array](auto& device) {
@@ -690,7 +690,7 @@ private:
                 VERIFY_NOT_REACHED();
         });
         array.finish();
-        return KSuccess;
+        return {};
     }
 };
 class ProcFSUptime final : public ProcFSGlobalInformation {
@@ -699,7 +699,7 @@ public:
 
 private:
     ProcFSUptime();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         return builder.appendff("{}\n", TimeManagement::the().uptime_ms() / 1000);
     }
@@ -710,11 +710,11 @@ public:
 
 private:
     ProcFSCommandLine();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         TRY(builder.append(kernel_command_line().string()));
         TRY(builder.append('\n'));
-        return KSuccess;
+        return {};
     }
 };
 class ProcFSSystemMode final : public ProcFSGlobalInformation {
@@ -723,11 +723,11 @@ public:
 
 private:
     ProcFSSystemMode();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         TRY(builder.append(kernel_command_line().system_mode()));
         TRY(builder.append('\n'));
-        return KSuccess;
+        return {};
     }
 };
 
@@ -739,12 +739,12 @@ public:
 
 private:
     ProcFSProfile();
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         if (!g_global_perf_events)
             return ENOENT;
         TRY(g_global_perf_events->to_json(builder));
-        return KSuccess;
+        return {};
     }
 };
 
@@ -757,7 +757,7 @@ private:
 
     virtual mode_t required_mode() const override { return 0400; }
 
-    virtual KResult try_generate(KBufferBuilder& builder) override
+    virtual ErrorOr<void> try_generate(KBufferBuilder& builder) override
     {
         if (!Process::current().is_superuser())
             return EPERM;
@@ -936,7 +936,7 @@ UNMAP_AFTER_INIT NonnullRefPtr<ProcFSRootDirectory> ProcFSRootDirectory::must_cr
     return directory;
 }
 
-KResult ProcFSRootDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> ProcFSRootDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(ProcFSComponentRegistry::the().get_lock());
     callback({ ".", { fsid, component_index() }, 0 });
@@ -953,15 +953,15 @@ KResult ProcFSRootDirectory::traverse_as_directory(unsigned fsid, Function<bool(
         callback({ String::formatted("{:d}", process.pid().value()), identifier, 0 });
         return IterationDecision::Continue;
     });
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<ProcFSExposedComponent>> ProcFSRootDirectory::lookup(StringView name)
+ErrorOr<NonnullRefPtr<ProcFSExposedComponent>> ProcFSRootDirectory::lookup(StringView name)
 {
     auto maybe_candidate = ProcFSExposedDirectory::lookup(name);
     if (maybe_candidate.is_error()) {
-        if (maybe_candidate.error() != ENOENT) {
-            return maybe_candidate.error();
+        if (maybe_candidate.error().code() != ENOENT) {
+            return maybe_candidate.release_error();
         }
     } else {
         return maybe_candidate.release_value();
@@ -973,10 +973,9 @@ KResultOr<NonnullRefPtr<ProcFSExposedComponent>> ProcFSRootDirectory::lookup(Str
         return ESRCH;
     auto actual_pid = pid.value();
 
-    auto maybe_process = Process::from_pid(actual_pid);
-    if (maybe_process) {
+    if (auto maybe_process = Process::from_pid(actual_pid))
         return maybe_process->procfs_traits();
-    }
+
     return ENOENT;
 }
 
diff --git a/Kernel/Graphics/Bochs/GraphicsAdapter.cpp b/Kernel/Graphics/Bochs/GraphicsAdapter.cpp
index 5bca91d48f6..9fd46427f1a 100644
--- a/Kernel/Graphics/Bochs/GraphicsAdapter.cpp
+++ b/Kernel/Graphics/Bochs/GraphicsAdapter.cpp
@@ -128,7 +128,7 @@ UNMAP_AFTER_INIT void BochsGraphicsAdapter::initialize_framebuffer_devices()
 {
     // FIXME: Find a better way to determine default resolution...
     m_framebuffer_device = FramebufferDevice::create(*this, PhysicalAddress(PCI::get_BAR0(pci_address()) & 0xfffffff0), 1024, 768, 1024 * sizeof(u32));
-    // FIXME: Would be nice to be able to return a KResult here.
+    // FIXME: Would be nice to be able to return a ErrorOr<void> here.
     VERIFY(!m_framebuffer_device->try_to_initialize().is_error());
 }
 
diff --git a/Kernel/Graphics/FramebufferDevice.cpp b/Kernel/Graphics/FramebufferDevice.cpp
index fae6bf5f0d8..8fa82ab28eb 100644
--- a/Kernel/Graphics/FramebufferDevice.cpp
+++ b/Kernel/Graphics/FramebufferDevice.cpp
@@ -27,7 +27,7 @@ NonnullRefPtr<FramebufferDevice> FramebufferDevice::create(const GenericGraphics
     return framebuffer_device_or_error.release_value();
 }
 
-KResultOr<Memory::Region*> FramebufferDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+ErrorOr<Memory::Region*> FramebufferDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     SpinlockLocker lock(m_activation_lock);
     REQUIRE_PROMISE(video);
@@ -92,7 +92,7 @@ void FramebufferDevice::activate_writes()
     m_graphical_writes_enabled = true;
 }
 
-UNMAP_AFTER_INIT KResult FramebufferDevice::try_to_initialize()
+UNMAP_AFTER_INIT ErrorOr<void> FramebufferDevice::try_to_initialize()
 {
     // FIXME: Would be nice to be able to unify this with mmap above, but this
     //        function is UNMAP_AFTER_INIT for the time being.
@@ -101,7 +101,7 @@ UNMAP_AFTER_INIT KResult FramebufferDevice::try_to_initialize()
     m_swapped_framebuffer_vmobject = TRY(Memory::AnonymousVMObject::try_create_with_size(Memory::page_round_up(framebuffer_length), AllocationStrategy::AllocateNow));
     m_real_framebuffer_region = TRY(MM.allocate_kernel_region_with_vmobject(*m_real_framebuffer_vmobject, Memory::page_round_up(framebuffer_length), "Framebuffer", Memory::Region::Access::ReadWrite));
     m_swapped_framebuffer_region = TRY(MM.allocate_kernel_region_with_vmobject(*m_swapped_framebuffer_vmobject, Memory::page_round_up(framebuffer_length), "Framebuffer Swap (Blank)", Memory::Region::Access::ReadWrite));
-    return KSuccess;
+    return {};
 }
 
 UNMAP_AFTER_INIT FramebufferDevice::FramebufferDevice(const GenericGraphicsAdapter& adapter, PhysicalAddress addr, size_t width, size_t height, size_t pitch)
@@ -118,7 +118,7 @@ UNMAP_AFTER_INIT FramebufferDevice::FramebufferDevice(const GenericGraphicsAdapt
     dbgln("Framebuffer {}: address={}, pitch={}, width={}, height={}", minor(), addr, pitch, width, height);
 }
 
-KResultOr<size_t> FramebufferDevice::buffer_length(size_t head) const
+ErrorOr<size_t> FramebufferDevice::buffer_length(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -127,13 +127,13 @@ KResultOr<size_t> FramebufferDevice::buffer_length(size_t head) const
     MutexLocker locker(m_resolution_lock);
     auto adapter = m_graphics_adapter.strong_ref();
     if (!adapter)
-        return KResult(EIO);
+        return Error::from_errno(EIO);
     if (adapter->double_framebuffering_capable())
         return m_framebuffer_pitch * m_framebuffer_height * 2;
     return m_framebuffer_pitch * m_framebuffer_height;
 }
 
-KResultOr<size_t> FramebufferDevice::pitch(size_t head) const
+ErrorOr<size_t> FramebufferDevice::pitch(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -142,7 +142,7 @@ KResultOr<size_t> FramebufferDevice::pitch(size_t head) const
     MutexLocker locker(m_resolution_lock);
     return m_framebuffer_pitch;
 }
-KResultOr<size_t> FramebufferDevice::height(size_t head) const
+ErrorOr<size_t> FramebufferDevice::height(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -151,7 +151,7 @@ KResultOr<size_t> FramebufferDevice::height(size_t head) const
     MutexLocker locker(m_resolution_lock);
     return m_framebuffer_height;
 }
-KResultOr<size_t> FramebufferDevice::width(size_t head) const
+ErrorOr<size_t> FramebufferDevice::width(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -160,7 +160,7 @@ KResultOr<size_t> FramebufferDevice::width(size_t head) const
     MutexLocker locker(m_resolution_lock);
     return m_framebuffer_width;
 }
-KResultOr<size_t> FramebufferDevice::vertical_offset(size_t head) const
+ErrorOr<size_t> FramebufferDevice::vertical_offset(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -169,7 +169,7 @@ KResultOr<size_t> FramebufferDevice::vertical_offset(size_t head) const
     MutexLocker locker(m_buffer_offset_lock);
     return m_y_offset;
 }
-KResultOr<bool> FramebufferDevice::vertical_offseted(size_t head) const
+ErrorOr<bool> FramebufferDevice::vertical_offseted(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -179,7 +179,7 @@ KResultOr<bool> FramebufferDevice::vertical_offseted(size_t head) const
     return m_y_offset == 0 ? 0 : 1;
 }
 
-KResult FramebufferDevice::set_head_resolution(size_t head, size_t width, size_t height, size_t)
+ErrorOr<void> FramebufferDevice::set_head_resolution(size_t head, size_t width, size_t height, size_t)
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -189,17 +189,17 @@ KResult FramebufferDevice::set_head_resolution(size_t head, size_t width, size_t
     MutexLocker resolution_locker(m_resolution_lock);
     auto adapter = m_graphics_adapter.strong_ref();
     if (!adapter)
-        return KResult(EIO);
+        return Error::from_errno(EIO);
     auto result = adapter->try_to_set_resolution(0, width, height);
-    // FIXME: Find a better way to return here a KResult.
+    // FIXME: Find a better way to return here a ErrorOr<void>.
     if (!result)
-        return KResult(ENOTSUP);
+        return Error::from_errno(ENOTSUP);
     m_framebuffer_width = width;
     m_framebuffer_height = height;
     m_framebuffer_pitch = width * sizeof(u32);
-    return KSuccess;
+    return {};
 }
-KResult FramebufferDevice::set_head_buffer(size_t head, bool second_buffer)
+ErrorOr<void> FramebufferDevice::set_head_buffer(size_t head, bool second_buffer)
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -208,30 +208,30 @@ KResult FramebufferDevice::set_head_buffer(size_t head, bool second_buffer)
     MutexLocker locker(m_buffer_offset_lock);
     auto adapter = m_graphics_adapter.strong_ref();
     if (!adapter)
-        return KResult(EIO);
+        return Error::from_errno(EIO);
     if (second_buffer) {
         if (!adapter->set_y_offset(0, m_framebuffer_height)) {
-            // FIXME: Find a better KResult here.
-            return KResult(ENOTSUP);
+            // FIXME: Find a better ErrorOr<void> here.
+            return Error::from_errno(ENOTSUP);
         }
         m_y_offset = m_framebuffer_height;
     } else {
         if (!adapter->set_y_offset(0, 0)) {
-            // FIXME: Find a better KResult here.
-            return KResult(ENOTSUP);
+            // FIXME: Find a better ErrorOr<void> here.
+            return Error::from_errno(ENOTSUP);
         }
         m_y_offset = 0;
     }
-    return KSuccess;
+    return {};
 }
-KResult FramebufferDevice::flush_head_buffer(size_t)
+ErrorOr<void> FramebufferDevice::flush_head_buffer(size_t)
 {
     // Note: This FramebufferDevice class doesn't support flushing.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
     // so if we happen to accidentally reach this code, assert.
     VERIFY_NOT_REACHED();
 }
-KResult FramebufferDevice::flush_rectangle(size_t, FBRect const&)
+ErrorOr<void> FramebufferDevice::flush_rectangle(size_t, FBRect const&)
 {
     // Note: This FramebufferDevice class doesn't support partial flushing.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
diff --git a/Kernel/Graphics/FramebufferDevice.h b/Kernel/Graphics/FramebufferDevice.h
index 4ad52883674..5b3785617d1 100644
--- a/Kernel/Graphics/FramebufferDevice.h
+++ b/Kernel/Graphics/FramebufferDevice.h
@@ -24,29 +24,29 @@ class FramebufferDevice final : public GenericFramebufferDevice {
 public:
     static NonnullRefPtr<FramebufferDevice> create(const GenericGraphicsAdapter&, PhysicalAddress, size_t, size_t, size_t);
 
-    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
 
     virtual void deactivate_writes() override;
     virtual void activate_writes() override;
 
-    virtual KResult try_to_initialize() override;
+    virtual ErrorOr<void> try_to_initialize() override;
 
     virtual bool multihead_support() const override { return false; }
     virtual bool flushing_support() const override { return false; }
     virtual bool partial_flushing_support() const override { return false; }
     virtual size_t heads_count() const override { return 1; }
-    virtual KResultOr<size_t> buffer_length(size_t head) const override;
-    virtual KResultOr<size_t> pitch(size_t head) const override;
-    virtual KResultOr<size_t> height(size_t head) const override;
-    virtual KResultOr<size_t> width(size_t head) const override;
-    virtual KResultOr<size_t> vertical_offset(size_t head) const override;
-    virtual KResultOr<bool> vertical_offseted(size_t head) const override;
+    virtual ErrorOr<size_t> buffer_length(size_t head) const override;
+    virtual ErrorOr<size_t> pitch(size_t head) const override;
+    virtual ErrorOr<size_t> height(size_t head) const override;
+    virtual ErrorOr<size_t> width(size_t head) const override;
+    virtual ErrorOr<size_t> vertical_offset(size_t head) const override;
+    virtual ErrorOr<bool> vertical_offseted(size_t head) const override;
 
 private:
-    virtual KResult set_head_resolution(size_t head, size_t width, size_t height, size_t pitch) override;
-    virtual KResult set_head_buffer(size_t head, bool second_buffer) override;
-    virtual KResult flush_head_buffer(size_t head) override;
-    virtual KResult flush_rectangle(size_t head, FBRect const&) override;
+    virtual ErrorOr<void> set_head_resolution(size_t head, size_t width, size_t height, size_t pitch) override;
+    virtual ErrorOr<void> set_head_buffer(size_t head, bool second_buffer) override;
+    virtual ErrorOr<void> flush_head_buffer(size_t head) override;
+    virtual ErrorOr<void> flush_rectangle(size_t head, FBRect const&) override;
 
     FramebufferDevice(const GenericGraphicsAdapter&, PhysicalAddress, size_t, size_t, size_t);
 
diff --git a/Kernel/Graphics/GenericFramebufferDevice.cpp b/Kernel/Graphics/GenericFramebufferDevice.cpp
index 3ac1a0a0eef..b241a1216e7 100644
--- a/Kernel/Graphics/GenericFramebufferDevice.cpp
+++ b/Kernel/Graphics/GenericFramebufferDevice.cpp
@@ -22,16 +22,16 @@
 
 namespace Kernel {
 
-KResult GenericFramebufferDevice::verify_head_index(int head_index) const
+ErrorOr<void> GenericFramebufferDevice::verify_head_index(int head_index) const
 {
     if (head_index < 0)
-        return KResult(EINVAL);
+        return Error::from_errno(EINVAL);
     if (!multihead_support() && head_index > 0)
-        return KResult(ENOTSUP);
-    return KSuccess;
+        return Error::from_errno(ENOTSUP);
+    return {};
 }
 
-KResult GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
+ErrorOr<void> GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     REQUIRE_PROMISE(video);
     switch (request) {
@@ -40,7 +40,7 @@ KResult GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request,
         FBProperties properties;
         auto adapter = m_graphics_adapter.strong_ref();
         if (!adapter)
-            return KResult(EIO);
+            return Error::from_errno(EIO);
         properties.multihead_support = multihead_support();
         properties.flushing_support = flushing_support();
         properties.doublebuffer_support = adapter->double_framebuffering_capable();
@@ -67,13 +67,13 @@ KResult GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request,
         TRY(verify_head_index(head_resolution.head_index));
 
         if (head_resolution.pitch < 0)
-            return KResult(EINVAL);
+            return Error::from_errno(EINVAL);
         if (head_resolution.width < 0)
-            return KResult(EINVAL);
+            return Error::from_errno(EINVAL);
         if (head_resolution.height < 0)
-            return KResult(EINVAL);
+            return Error::from_errno(EINVAL);
         TRY(set_head_resolution(head_resolution.head_index, head_resolution.width, head_resolution.height, head_resolution.pitch));
-        return KSuccess;
+        return {};
     }
     case FB_IOCTL_SET_HEAD_VERTICAL_OFFSET_BUFFER: {
         auto user_head_vertical_buffer_offset = static_ptr_cast<FBHeadVerticalOffset*>(arg);
@@ -82,9 +82,9 @@ KResult GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request,
         TRY(verify_head_index(head_vertical_buffer_offset.head_index));
 
         if (head_vertical_buffer_offset.offseted < 0 || head_vertical_buffer_offset.offseted > 1)
-            return KResult(EINVAL);
+            return Error::from_errno(EINVAL);
         TRY(set_head_buffer(head_vertical_buffer_offset.head_index, head_vertical_buffer_offset.offseted));
-        return KSuccess;
+        return {};
     }
     case FB_IOCTL_GET_HEAD_VERTICAL_OFFSET_BUFFER: {
         auto user_head_vertical_buffer_offset = static_ptr_cast<FBHeadVerticalOffset*>(arg);
@@ -97,12 +97,12 @@ KResult GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request,
     }
     case FB_IOCTL_FLUSH_HEAD_BUFFERS: {
         if (!partial_flushing_support())
-            return KResult(ENOTSUP);
+            return Error::from_errno(ENOTSUP);
         auto user_flush_rects = static_ptr_cast<FBFlushRects*>(arg);
         FBFlushRects flush_rects;
         TRY(copy_from_user(&flush_rects, user_flush_rects));
         if (Checked<unsigned>::multiplication_would_overflow(flush_rects.count, sizeof(FBRect)))
-            return KResult(EFAULT);
+            return Error::from_errno(EFAULT);
         MutexLocker locker(m_flushing_lock);
         if (flush_rects.count > 0) {
             for (unsigned i = 0; i < flush_rects.count; i++) {
@@ -111,11 +111,11 @@ KResult GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request,
                 TRY(flush_rectangle(flush_rects.buffer_index, user_dirty_rect));
             }
         }
-        return KSuccess;
+        return {};
     };
     case FB_IOCTL_FLUSH_HEAD: {
         if (!flushing_support())
-            return KResult(ENOTSUP);
+            return Error::from_errno(ENOTSUP);
         // Note: We accept a FBRect, but we only really care about the head_index value.
         auto user_rect = static_ptr_cast<FBRect*>(arg);
         FBRect rect;
@@ -123,7 +123,7 @@ KResult GenericFramebufferDevice::ioctl(OpenFileDescription&, unsigned request,
         TRY(verify_head_index(rect.head_index));
 
         TRY(flush_head_buffer(rect.head_index));
-        return KSuccess;
+        return {};
     }
     default:
         return EINVAL;
diff --git a/Kernel/Graphics/GenericFramebufferDevice.h b/Kernel/Graphics/GenericFramebufferDevice.h
index 6fbce789dd5..cee22157326 100644
--- a/Kernel/Graphics/GenericFramebufferDevice.h
+++ b/Kernel/Graphics/GenericFramebufferDevice.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/String.h>
 #include <AK/Types.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Devices/BlockDevice.h>
 #include <Kernel/Graphics/GenericGraphicsAdapter.h>
 #include <Kernel/Locking/Mutex.h>
@@ -21,7 +21,7 @@ class GenericFramebufferDevice : public BlockDevice {
     friend class DeviceManagement;
 
 public:
-    virtual KResult try_to_initialize() = 0;
+    virtual ErrorOr<void> try_to_initialize() = 0;
 
     virtual void deactivate_writes() = 0;
     virtual void activate_writes() = 0;
@@ -29,8 +29,8 @@ public:
     virtual ~GenericFramebufferDevice() = default;
 
     // ^File
-    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) = 0;
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override final;
+    virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) = 0;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override final;
     virtual StringView class_name() const override final { return "FramebufferDevice"sv; }
 
 private:
@@ -38,28 +38,28 @@ private:
     virtual bool can_read(const OpenFileDescription&, size_t) const override final { return true; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override final { return true; }
     virtual void start_request(AsyncBlockDeviceRequest& request) override final { request.complete(AsyncDeviceRequest::Failure); }
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return EINVAL; }
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EINVAL; }
 
 protected:
     virtual bool multihead_support() const = 0;
     virtual bool flushing_support() const = 0;
     virtual bool partial_flushing_support() const = 0;
     virtual size_t heads_count() const = 0;
-    virtual KResultOr<size_t> buffer_length(size_t head) const = 0;
-    virtual KResultOr<size_t> pitch(size_t head) const = 0;
-    virtual KResultOr<size_t> height(size_t head) const = 0;
-    virtual KResultOr<size_t> width(size_t head) const = 0;
-    virtual KResultOr<size_t> vertical_offset(size_t head) const = 0;
-    virtual KResultOr<bool> vertical_offseted(size_t head) const = 0;
+    virtual ErrorOr<size_t> buffer_length(size_t head) const = 0;
+    virtual ErrorOr<size_t> pitch(size_t head) const = 0;
+    virtual ErrorOr<size_t> height(size_t head) const = 0;
+    virtual ErrorOr<size_t> width(size_t head) const = 0;
+    virtual ErrorOr<size_t> vertical_offset(size_t head) const = 0;
+    virtual ErrorOr<bool> vertical_offseted(size_t head) const = 0;
 
-    virtual KResult set_head_resolution(size_t head, size_t width, size_t height, size_t pitch) = 0;
-    virtual KResult set_head_buffer(size_t head, bool second_buffer) = 0;
-    virtual KResult flush_head_buffer(size_t head) = 0;
+    virtual ErrorOr<void> set_head_resolution(size_t head, size_t width, size_t height, size_t pitch) = 0;
+    virtual ErrorOr<void> set_head_buffer(size_t head, bool second_buffer) = 0;
+    virtual ErrorOr<void> flush_head_buffer(size_t head) = 0;
     // FIXME: This method is too much specific to the VirtIO implementation (especially the buffer_index parameter)
-    virtual KResult flush_rectangle(size_t buffer_index, FBRect const&) = 0;
+    virtual ErrorOr<void> flush_rectangle(size_t buffer_index, FBRect const&) = 0;
 
-    KResult verify_head_index(int head_index) const;
+    ErrorOr<void> verify_head_index(int head_index) const;
 
     GenericFramebufferDevice(const GenericGraphicsAdapter&);
     mutable WeakPtr<GenericGraphicsAdapter> m_graphics_adapter;
diff --git a/Kernel/Graphics/Intel/NativeGraphicsAdapter.cpp b/Kernel/Graphics/Intel/NativeGraphicsAdapter.cpp
index 71d79dcf0ff..2ef73ab4c9c 100644
--- a/Kernel/Graphics/Intel/NativeGraphicsAdapter.cpp
+++ b/Kernel/Graphics/Intel/NativeGraphicsAdapter.cpp
@@ -643,7 +643,7 @@ void IntelNativeGraphicsAdapter::initialize_framebuffer_devices()
     VERIFY(m_framebuffer_height != 0);
     VERIFY(m_framebuffer_width != 0);
     m_framebuffer_device = FramebufferDevice::create(*this, address, m_framebuffer_width, m_framebuffer_height, m_framebuffer_pitch);
-    // FIXME: Would be nice to be able to return a KResult here.
+    // FIXME: Would be nice to be able to return a ErrorOr<void> here.
     auto framebuffer_result = m_framebuffer_device->try_to_initialize();
     VERIFY(!framebuffer_result.is_error());
 }
diff --git a/Kernel/Graphics/VGACompatibleAdapter.cpp b/Kernel/Graphics/VGACompatibleAdapter.cpp
index 49500519151..d64da3897ba 100644
--- a/Kernel/Graphics/VGACompatibleAdapter.cpp
+++ b/Kernel/Graphics/VGACompatibleAdapter.cpp
@@ -32,7 +32,7 @@ UNMAP_AFTER_INIT void VGACompatibleAdapter::initialize_framebuffer_devices()
     VERIFY(m_framebuffer_height != 0);
     VERIFY(m_framebuffer_pitch != 0);
     m_framebuffer_device = FramebufferDevice::create(*this, m_framebuffer_address, m_framebuffer_width, m_framebuffer_height, m_framebuffer_pitch);
-    // FIXME: Would be nice to be able to return KResult here.
+    // FIXME: Would be nice to be able to return ErrorOr<void> here.
     VERIFY(!m_framebuffer_device->try_to_initialize().is_error());
 }
 
diff --git a/Kernel/Graphics/VirtIOGPU/FramebufferDevice.cpp b/Kernel/Graphics/VirtIOGPU/FramebufferDevice.cpp
index 0c20aa655f6..7072bc828d5 100644
--- a/Kernel/Graphics/VirtIOGPU/FramebufferDevice.cpp
+++ b/Kernel/Graphics/VirtIOGPU/FramebufferDevice.cpp
@@ -19,7 +19,7 @@ RefPtr<GraphicsAdapter> FramebufferDevice::adapter() const
     return static_cast<GraphicsAdapter&>(*adapter);
 }
 
-KResultOr<size_t> FramebufferDevice::buffer_length(size_t head) const
+ErrorOr<size_t> FramebufferDevice::buffer_length(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -28,7 +28,7 @@ KResultOr<size_t> FramebufferDevice::buffer_length(size_t head) const
     MutexLocker locker(m_resolution_lock);
     return display_info().rect.width * display_info().rect.height * 4;
 }
-KResultOr<size_t> FramebufferDevice::pitch(size_t head) const
+ErrorOr<size_t> FramebufferDevice::pitch(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -37,7 +37,7 @@ KResultOr<size_t> FramebufferDevice::pitch(size_t head) const
     MutexLocker locker(m_resolution_lock);
     return display_info().rect.width * 4;
 }
-KResultOr<size_t> FramebufferDevice::height(size_t head) const
+ErrorOr<size_t> FramebufferDevice::height(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -46,7 +46,7 @@ KResultOr<size_t> FramebufferDevice::height(size_t head) const
     MutexLocker locker(m_resolution_lock);
     return display_info().rect.height;
 }
-KResultOr<size_t> FramebufferDevice::width(size_t head) const
+ErrorOr<size_t> FramebufferDevice::width(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -55,7 +55,7 @@ KResultOr<size_t> FramebufferDevice::width(size_t head) const
     MutexLocker locker(m_resolution_lock);
     return display_info().rect.width;
 }
-KResultOr<size_t> FramebufferDevice::vertical_offset(size_t head) const
+ErrorOr<size_t> FramebufferDevice::vertical_offset(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -63,7 +63,7 @@ KResultOr<size_t> FramebufferDevice::vertical_offset(size_t head) const
     VERIFY(head == 0);
     return 0;
 }
-KResultOr<bool> FramebufferDevice::vertical_offseted(size_t head) const
+ErrorOr<bool> FramebufferDevice::vertical_offseted(size_t head) const
 {
     // Note: This FramebufferDevice class doesn't support multihead setup.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
@@ -72,14 +72,14 @@ KResultOr<bool> FramebufferDevice::vertical_offseted(size_t head) const
     return false;
 }
 
-KResult FramebufferDevice::set_head_resolution(size_t head, size_t width, size_t height, size_t)
+ErrorOr<void> FramebufferDevice::set_head_resolution(size_t head, size_t width, size_t height, size_t)
 {
     // Note: This class doesn't support multihead setup (yet!).
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
     // so if we happen to accidentally have a value different than 0, assert.
     VERIFY(head == 0);
     if (width > MAX_VIRTIOGPU_RESOLUTION_WIDTH || height > MAX_VIRTIOGPU_RESOLUTION_HEIGHT)
-        return KResult(ENOTSUP);
+        return Error::from_errno(ENOTSUP);
 
     auto& info = display_info();
 
@@ -92,22 +92,22 @@ KResult FramebufferDevice::set_head_resolution(size_t head, size_t width, size_t
         .height = (u32)height,
     };
 
-    // FIXME: Would be nice to be able to return KResultOr here.
+    // FIXME: Would be nice to be able to return ErrorOr here.
     TRY(create_framebuffer());
-    return KSuccess;
+    return {};
 }
-KResult FramebufferDevice::set_head_buffer(size_t, bool)
+ErrorOr<void> FramebufferDevice::set_head_buffer(size_t, bool)
 {
-    return KResult(ENOTSUP);
+    return Error::from_errno(ENOTSUP);
 }
-KResult FramebufferDevice::flush_head_buffer(size_t)
+ErrorOr<void> FramebufferDevice::flush_head_buffer(size_t)
 {
     // Note: This class doesn't support flushing.
     // We take care to verify this at the GenericFramebufferDevice::ioctl method
     // so if we happen to accidentally reach this code, assert.
     VERIFY_NOT_REACHED();
 }
-KResult FramebufferDevice::flush_rectangle(size_t buffer_index, FBRect const& rect)
+ErrorOr<void> FramebufferDevice::flush_rectangle(size_t buffer_index, FBRect const& rect)
 {
     MutexLocker locker(adapter()->operation_lock());
     Protocol::Rect dirty_rect {
@@ -116,9 +116,9 @@ KResult FramebufferDevice::flush_rectangle(size_t buffer_index, FBRect const& re
         .width = rect.width,
         .height = rect.height
     };
-    // FIXME: Find a better KResult here.
+    // FIXME: Find a better ErrorOr<void> here.
     if (!m_are_writes_active)
-        return KResult(EIO);
+        return Error::from_errno(EIO);
     auto& buffer = buffer_from_index(buffer_index);
     transfer_framebuffer_data_to_host(dirty_rect, buffer);
     if (&buffer == m_current_buffer) {
@@ -137,7 +137,7 @@ KResult FramebufferDevice::flush_rectangle(size_t buffer_index, FBRect const& re
             buffer.dirty_rect.height = max(current_dirty_bottom, dirty_rect.y + dirty_rect.height) - buffer.dirty_rect.y;
         }
     }
-    return KSuccess;
+    return {};
 }
 
 FramebufferDevice::FramebufferDevice(GraphicsAdapter const& adapter, ScanoutID scanout)
@@ -155,7 +155,7 @@ FramebufferDevice::~FramebufferDevice()
 {
 }
 
-KResult FramebufferDevice::create_framebuffer()
+ErrorOr<void> FramebufferDevice::create_framebuffer()
 {
     // First delete any existing framebuffers to free the memory first
     m_framebuffer = nullptr;
@@ -179,7 +179,7 @@ KResult FramebufferDevice::create_framebuffer()
     create_buffer(m_main_buffer, 0, m_buffer_size);
     create_buffer(m_back_buffer, m_buffer_size, m_buffer_size);
 
-    return KSuccess;
+    return {};
 }
 
 void FramebufferDevice::create_buffer(Buffer& buffer, size_t framebuffer_offset, size_t framebuffer_size)
@@ -255,7 +255,7 @@ void FramebufferDevice::set_buffer(int buffer_index)
     buffer.dirty_rect = {};
 }
 
-KResultOr<Memory::Region*> FramebufferDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
+ErrorOr<Memory::Region*> FramebufferDevice::mmap(Process& process, OpenFileDescription&, Memory::VirtualRange const& range, u64 offset, int prot, bool shared)
 {
     REQUIRE_PROMISE(video);
     if (!shared)
@@ -295,7 +295,7 @@ void FramebufferDevice::deactivate_writes()
     if (m_userspace_mmap_region) {
         auto* region = m_userspace_mmap_region.unsafe_ptr();
         auto maybe_vm_object = m_framebuffer_sink_vmobject->try_clone();
-        // FIXME: Would be nice to be able to return a KResult here.
+        // FIXME: Would be nice to be able to return a ErrorOr<void> here.
         VERIFY(!maybe_vm_object.is_error());
         region->set_vmobject(maybe_vm_object.release_value());
         region->remap();
diff --git a/Kernel/Graphics/VirtIOGPU/FramebufferDevice.h b/Kernel/Graphics/VirtIOGPU/FramebufferDevice.h
index b643691fb22..fd45d84e731 100644
--- a/Kernel/Graphics/VirtIOGPU/FramebufferDevice.h
+++ b/Kernel/Graphics/VirtIOGPU/FramebufferDevice.h
@@ -28,7 +28,7 @@ public:
     FramebufferDevice(GraphicsAdapter const&, ScanoutID);
     virtual ~FramebufferDevice() override;
 
-    virtual KResult try_to_initialize() override { return KSuccess; }
+    virtual ErrorOr<void> try_to_initialize() override { return {}; }
 
     virtual void deactivate_writes();
     virtual void activate_writes();
@@ -50,17 +50,17 @@ private:
     virtual bool flushing_support() const override { return false; }
     virtual bool partial_flushing_support() const override { return true; }
     virtual size_t heads_count() const override { return 1; }
-    virtual KResultOr<size_t> buffer_length(size_t head) const override;
-    virtual KResultOr<size_t> pitch(size_t head) const override;
-    virtual KResultOr<size_t> height(size_t head) const override;
-    virtual KResultOr<size_t> width(size_t head) const override;
-    virtual KResultOr<size_t> vertical_offset(size_t head) const override;
-    virtual KResultOr<bool> vertical_offseted(size_t head) const override;
+    virtual ErrorOr<size_t> buffer_length(size_t head) const override;
+    virtual ErrorOr<size_t> pitch(size_t head) const override;
+    virtual ErrorOr<size_t> height(size_t head) const override;
+    virtual ErrorOr<size_t> width(size_t head) const override;
+    virtual ErrorOr<size_t> vertical_offset(size_t head) const override;
+    virtual ErrorOr<bool> vertical_offseted(size_t head) const override;
 
-    virtual KResult set_head_resolution(size_t head, size_t width, size_t height, size_t pitch) override;
-    virtual KResult set_head_buffer(size_t head, bool second_buffer) override;
-    virtual KResult flush_head_buffer(size_t head) override;
-    virtual KResult flush_rectangle(size_t head, FBRect const&) override;
+    virtual ErrorOr<void> set_head_resolution(size_t head, size_t width, size_t height, size_t pitch) override;
+    virtual ErrorOr<void> set_head_buffer(size_t head, bool second_buffer) override;
+    virtual ErrorOr<void> flush_head_buffer(size_t head) override;
+    virtual ErrorOr<void> flush_rectangle(size_t head, FBRect const&) override;
 
     void flush_dirty_window(Protocol::Rect const&, Buffer&);
     void transfer_framebuffer_data_to_host(Protocol::Rect const&, Buffer&);
@@ -73,11 +73,11 @@ private:
 
     void clear_to_black(Buffer&);
 
-    KResult create_framebuffer();
+    ErrorOr<void> create_framebuffer();
     void create_buffer(Buffer&, size_t, size_t);
     void set_buffer(int);
 
-    virtual KResultOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
+    virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
 
     static bool is_valid_buffer_index(int buffer_index)
     {
diff --git a/Kernel/Interrupts/APIC.cpp b/Kernel/Interrupts/APIC.cpp
index 960fa6cf2b0..b7ad320c24e 100644
--- a/Kernel/Interrupts/APIC.cpp
+++ b/Kernel/Interrupts/APIC.cpp
@@ -309,7 +309,7 @@ UNMAP_AFTER_INIT bool APIC::init_bsp()
 UNMAP_AFTER_INIT static NonnullOwnPtr<Memory::Region> create_identity_mapped_region(PhysicalAddress paddr, size_t size)
 {
     auto maybe_vmobject = Memory::AnonymousVMObject::try_create_for_physical_range(paddr, size);
-    // FIXME: Would be nice to be able to return a KResultOr from here.
+    // FIXME: Would be nice to be able to return a ErrorOr from here.
     VERIFY(!maybe_vmobject.is_error());
 
     auto region_or_error = MM.allocate_kernel_region_with_vmobject(
diff --git a/Kernel/KBuffer.h b/Kernel/KBuffer.h
index 2a564101781..0b4a6991743 100644
--- a/Kernel/KBuffer.h
+++ b/Kernel/KBuffer.h
@@ -24,13 +24,13 @@ namespace Kernel {
 
 class [[nodiscard]] KBuffer {
 public:
-    static KResultOr<NonnullOwnPtr<KBuffer>> try_create_with_size(size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
+    static ErrorOr<NonnullOwnPtr<KBuffer>> try_create_with_size(size_t size, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
     {
         auto region = TRY(MM.allocate_kernel_region(Memory::page_round_up(size), name, access, strategy));
         return TRY(adopt_nonnull_own_or_enomem(new (nothrow) KBuffer { size, move(region) }));
     }
 
-    static KResultOr<NonnullOwnPtr<KBuffer>> try_create_with_bytes(ReadonlyBytes bytes, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
+    static ErrorOr<NonnullOwnPtr<KBuffer>> try_create_with_bytes(ReadonlyBytes bytes, Memory::Region::Access access = Memory::Region::Access::ReadWrite, StringView name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
     {
         auto buffer = TRY(try_create_with_size(bytes.size(), access, name, strategy));
         memcpy(buffer->data(), bytes.data(), bytes.size());
diff --git a/Kernel/KBufferBuilder.cpp b/Kernel/KBufferBuilder.cpp
index 4a2f9d1da06..cc944e93031 100644
--- a/Kernel/KBufferBuilder.cpp
+++ b/Kernel/KBufferBuilder.cpp
@@ -46,7 +46,7 @@ OwnPtr<KBuffer> KBufferBuilder::build()
     return move(m_buffer);
 }
 
-KResultOr<KBufferBuilder> KBufferBuilder::try_create()
+ErrorOr<KBufferBuilder> KBufferBuilder::try_create()
 {
     auto buffer = TRY(KBuffer::try_create_with_size(4 * MiB, Memory::Region::Access::ReadWrite));
     return KBufferBuilder { move(buffer) };
@@ -57,47 +57,47 @@ KBufferBuilder::KBufferBuilder(NonnullOwnPtr<KBuffer> buffer)
 {
 }
 
-KResult KBufferBuilder::append_bytes(ReadonlyBytes bytes)
+ErrorOr<void> KBufferBuilder::append_bytes(ReadonlyBytes bytes)
 {
     if (!check_expand(bytes.size()))
         return ENOMEM;
     memcpy(insertion_ptr(), bytes.data(), bytes.size());
     m_size += bytes.size();
-    return KSuccess;
+    return {};
 }
 
-KResult KBufferBuilder::append(const StringView& str)
+ErrorOr<void> KBufferBuilder::append(const StringView& str)
 {
     if (str.is_empty())
-        return KSuccess;
+        return {};
     if (!check_expand(str.length()))
         return ENOMEM;
     memcpy(insertion_ptr(), str.characters_without_null_termination(), str.length());
     m_size += str.length();
-    return KSuccess;
+    return {};
 }
 
-KResult KBufferBuilder::append(const char* characters, int length)
+ErrorOr<void> KBufferBuilder::append(const char* characters, int length)
 {
     if (!length)
-        return KSuccess;
+        return {};
     if (!check_expand(length))
         return ENOMEM;
     memcpy(insertion_ptr(), characters, length);
     m_size += length;
-    return KSuccess;
+    return {};
 }
 
-KResult KBufferBuilder::append(char ch)
+ErrorOr<void> KBufferBuilder::append(char ch)
 {
     if (!check_expand(1))
         return ENOMEM;
     insertion_ptr()[0] = ch;
     m_size += 1;
-    return KSuccess;
+    return {};
 }
 
-KResult KBufferBuilder::append_escaped_for_json(const StringView& string)
+ErrorOr<void> KBufferBuilder::append_escaped_for_json(const StringView& string)
 {
     for (auto ch : string) {
         switch (ch) {
@@ -123,7 +123,7 @@ KResult KBufferBuilder::append_escaped_for_json(const StringView& string)
                 TRY(append(ch));
         }
     }
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/KBufferBuilder.h b/Kernel/KBufferBuilder.h
index 06be3c0d6de..e46f4bc462f 100644
--- a/Kernel/KBufferBuilder.h
+++ b/Kernel/KBufferBuilder.h
@@ -18,21 +18,21 @@ class KBufferBuilder {
 public:
     using OutputType = KBuffer;
 
-    static KResultOr<KBufferBuilder> try_create();
+    static ErrorOr<KBufferBuilder> try_create();
 
     KBufferBuilder(KBufferBuilder&&) = default;
     KBufferBuilder& operator=(KBufferBuilder&&) = default;
     ~KBufferBuilder() = default;
 
-    KResult append(const StringView&);
-    KResult append(char);
-    KResult append(const char*, int);
+    ErrorOr<void> append(const StringView&);
+    ErrorOr<void> append(char);
+    ErrorOr<void> append(const char*, int);
 
-    KResult append_escaped_for_json(const StringView&);
-    KResult append_bytes(ReadonlyBytes);
+    ErrorOr<void> append_escaped_for_json(const StringView&);
+    ErrorOr<void> append_bytes(ReadonlyBytes);
 
     template<typename... Parameters>
-    KResult appendff(CheckedFormatString<Parameters...>&& fmtstr, const Parameters&... parameters)
+    ErrorOr<void> appendff(CheckedFormatString<Parameters...>&& fmtstr, const Parameters&... parameters)
     {
         // FIXME: This really not ideal, but vformat expects StringBuilder.
         StringBuilder builder;
diff --git a/Kernel/KLexicalPath.cpp b/Kernel/KLexicalPath.cpp
index 1cdd9fb35fc..f3ed1b13354 100644
--- a/Kernel/KLexicalPath.cpp
+++ b/Kernel/KLexicalPath.cpp
@@ -62,7 +62,7 @@ Vector<StringView> parts(StringView const& path)
     return path.split_view('/');
 }
 
-KResultOr<NonnullOwnPtr<KString>> try_join(StringView const& first, StringView const& second)
+ErrorOr<NonnullOwnPtr<KString>> try_join(StringView const& first, StringView const& second)
 {
     VERIFY(is_canonical(first));
     VERIFY(is_canonical(second));
diff --git a/Kernel/KLexicalPath.h b/Kernel/KLexicalPath.h
index a8564fd81c2..e2cdc06df87 100644
--- a/Kernel/KLexicalPath.h
+++ b/Kernel/KLexicalPath.h
@@ -17,6 +17,6 @@ StringView basename(StringView const&);
 StringView dirname(StringView const&);
 Vector<StringView> parts(StringView const&);
 
-KResultOr<NonnullOwnPtr<KString>> try_join(StringView const&, StringView const&);
+ErrorOr<NonnullOwnPtr<KString>> try_join(StringView const&, StringView const&);
 
 }
diff --git a/Kernel/KString.cpp b/Kernel/KString.cpp
index 8a6582c7cd1..d20fd6e374c 100644
--- a/Kernel/KString.cpp
+++ b/Kernel/KString.cpp
@@ -10,7 +10,7 @@ extern bool g_in_early_boot;
 
 namespace Kernel {
 
-KResultOr<NonnullOwnPtr<KString>> KString::try_create(StringView string)
+ErrorOr<NonnullOwnPtr<KString>> KString::try_create(StringView string)
 {
     char* characters = nullptr;
     size_t length = string.length();
@@ -28,7 +28,7 @@ NonnullOwnPtr<KString> KString::must_create(StringView string)
     return KString::try_create(string).release_value();
 }
 
-KResultOr<NonnullOwnPtr<KString>> KString::try_create_uninitialized(size_t length, char*& characters)
+ErrorOr<NonnullOwnPtr<KString>> KString::try_create_uninitialized(size_t length, char*& characters)
 {
     size_t allocation_size = sizeof(KString) + (sizeof(char) * length) + sizeof(char);
     auto* slot = kmalloc(allocation_size);
@@ -46,7 +46,7 @@ NonnullOwnPtr<KString> KString::must_create_uninitialized(size_t length, char*&
     return KString::try_create_uninitialized(length, characters).release_value();
 }
 
-KResultOr<NonnullOwnPtr<KString>> KString::try_clone() const
+ErrorOr<NonnullOwnPtr<KString>> KString::try_clone() const
 {
     return try_create(view());
 }
diff --git a/Kernel/KString.h b/Kernel/KString.h
index 44fc324d603..d92f400df26 100644
--- a/Kernel/KString.h
+++ b/Kernel/KString.h
@@ -16,14 +16,14 @@ class KString {
     AK_MAKE_NONMOVABLE(KString);
 
 public:
-    [[nodiscard]] static KResultOr<NonnullOwnPtr<KString>> try_create_uninitialized(size_t, char*&);
+    [[nodiscard]] static ErrorOr<NonnullOwnPtr<KString>> try_create_uninitialized(size_t, char*&);
     [[nodiscard]] static NonnullOwnPtr<KString> must_create_uninitialized(size_t, char*&);
-    [[nodiscard]] static KResultOr<NonnullOwnPtr<KString>> try_create(StringView);
+    [[nodiscard]] static ErrorOr<NonnullOwnPtr<KString>> try_create(StringView);
     [[nodiscard]] static NonnullOwnPtr<KString> must_create(StringView);
 
     void operator delete(void*);
 
-    KResultOr<NonnullOwnPtr<KString>> try_clone() const;
+    ErrorOr<NonnullOwnPtr<KString>> try_clone() const;
 
     [[nodiscard]] bool is_empty() const { return m_length == 0; }
     [[nodiscard]] size_t length() const { return m_length; }
diff --git a/Kernel/Library/ThreadSafeRefPtr.h b/Kernel/Library/ThreadSafeRefPtr.h
index 50971a53d95..8253c7b8bb7 100644
--- a/Kernel/Library/ThreadSafeRefPtr.h
+++ b/Kernel/Library/ThreadSafeRefPtr.h
@@ -8,13 +8,13 @@
 
 #include <AK/Assertions.h>
 #include <AK/Atomic.h>
+#include <AK/Error.h>
 #include <AK/Format.h>
 #include <AK/NonnullRefPtr.h>
 #include <AK/StdLibExtras.h>
 #include <AK/Traits.h>
 #include <AK/Types.h>
 #ifdef KERNEL
-#    include <Kernel/API/KResult.h>
 #    include <Kernel/Arch/Processor.h>
 #    include <Kernel/Arch/ScopedCritical.h>
 #endif
@@ -498,16 +498,14 @@ inline RefPtr<T> try_make_ref_counted(Args&&... args)
     return adopt_ref_if_nonnull(new (nothrow) T { forward<Args>(args)... });
 }
 
-#ifdef KERNEL
 template<typename T>
-inline Kernel::KResultOr<NonnullRefPtr<T>> adopt_nonnull_ref_or_enomem(T* object)
+inline ErrorOr<NonnullRefPtr<T>> adopt_nonnull_ref_or_enomem(T* object)
 {
     auto result = adopt_ref_if_nonnull(object);
     if (!result)
-        return ENOMEM;
+        return Error::from_errno(ENOMEM);
     return result.release_nonnull();
 }
-#endif
 
 }
 
diff --git a/Kernel/Memory/AddressSpace.cpp b/Kernel/Memory/AddressSpace.cpp
index 55795179109..f0ce03dc243 100644
--- a/Kernel/Memory/AddressSpace.cpp
+++ b/Kernel/Memory/AddressSpace.cpp
@@ -15,7 +15,7 @@
 
 namespace Kernel::Memory {
 
-KResultOr<NonnullOwnPtr<AddressSpace>> AddressSpace::try_create(AddressSpace const* parent)
+ErrorOr<NonnullOwnPtr<AddressSpace>> AddressSpace::try_create(AddressSpace const* parent)
 {
     auto page_directory = TRY(PageDirectory::try_create_for_userspace(parent ? &parent->page_directory().range_allocator() : nullptr));
     auto space = TRY(adopt_nonnull_own_or_enomem(new (nothrow) AddressSpace(page_directory)));
@@ -32,7 +32,7 @@ AddressSpace::~AddressSpace()
 {
 }
 
-KResult AddressSpace::unmap_mmap_range(VirtualAddress addr, size_t size)
+ErrorOr<void> AddressSpace::unmap_mmap_range(VirtualAddress addr, size_t size)
 {
     if (!size)
         return EINVAL;
@@ -49,7 +49,7 @@ KResult AddressSpace::unmap_mmap_range(VirtualAddress addr, size_t size)
         PerformanceManager::add_unmap_perf_event(Process::current(), whole_region->range());
 
         deallocate_region(*whole_region);
-        return KSuccess;
+        return {};
     }
 
     if (auto* old_region = find_region_containing(range_to_unmap)) {
@@ -77,13 +77,13 @@ KResult AddressSpace::unmap_mmap_range(VirtualAddress addr, size_t size)
 
         PerformanceManager::add_unmap_perf_event(Process::current(), range_to_unmap);
 
-        return KSuccess;
+        return {};
     }
 
     // Try again while checking multiple regions at a time.
     auto const& regions = find_regions_intersecting(range_to_unmap);
     if (regions.is_empty())
-        return KSuccess;
+        return {};
 
     // Check if any of the regions is not mmap'ed, to not accidentally
     // error out with just half a region map left.
@@ -126,10 +126,10 @@ KResult AddressSpace::unmap_mmap_range(VirtualAddress addr, size_t size)
 
     PerformanceManager::add_unmap_perf_event(Process::current(), range_to_unmap);
 
-    return KSuccess;
+    return {};
 }
 
-KResultOr<VirtualRange> AddressSpace::try_allocate_range(VirtualAddress vaddr, size_t size, size_t alignment)
+ErrorOr<VirtualRange> AddressSpace::try_allocate_range(VirtualAddress vaddr, size_t size, size_t alignment)
 {
     vaddr.mask(PAGE_MASK);
     size = page_round_up(size);
@@ -138,7 +138,7 @@ KResultOr<VirtualRange> AddressSpace::try_allocate_range(VirtualAddress vaddr, s
     return page_directory().range_allocator().try_allocate_specific(vaddr, size);
 }
 
-KResultOr<Region*> AddressSpace::try_allocate_split_region(Region const& source_region, VirtualRange const& range, size_t offset_in_vmobject)
+ErrorOr<Region*> AddressSpace::try_allocate_split_region(Region const& source_region, VirtualRange const& range, size_t offset_in_vmobject)
 {
     OwnPtr<KString> region_name;
     if (!source_region.name().is_null())
@@ -158,7 +158,7 @@ KResultOr<Region*> AddressSpace::try_allocate_split_region(Region const& source_
     return region;
 }
 
-KResultOr<Region*> AddressSpace::allocate_region(VirtualRange const& range, StringView name, int prot, AllocationStrategy strategy)
+ErrorOr<Region*> AddressSpace::allocate_region(VirtualRange const& range, StringView name, int prot, AllocationStrategy strategy)
 {
     VERIFY(range.is_valid());
     OwnPtr<KString> region_name;
@@ -170,7 +170,7 @@ KResultOr<Region*> AddressSpace::allocate_region(VirtualRange const& range, Stri
     return add_region(move(region));
 }
 
-KResultOr<Region*> AddressSpace::allocate_region_with_vmobject(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, StringView name, int prot, bool shared)
+ErrorOr<Region*> AddressSpace::allocate_region_with_vmobject(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, StringView name, int prot, bool shared)
 {
     VERIFY(range.is_valid());
     size_t end_in_vmobject = offset_in_vmobject + range.size();
@@ -264,7 +264,7 @@ Vector<Region*> AddressSpace::find_regions_intersecting(VirtualRange const& rang
     return regions;
 }
 
-KResultOr<Region*> AddressSpace::add_region(NonnullOwnPtr<Region> region)
+ErrorOr<Region*> AddressSpace::add_region(NonnullOwnPtr<Region> region)
 {
     auto* ptr = region.ptr();
     SpinlockLocker lock(m_lock);
@@ -274,13 +274,13 @@ KResultOr<Region*> AddressSpace::add_region(NonnullOwnPtr<Region> region)
 }
 
 // Carve out a virtual address range from a region and return the two regions on either side
-KResultOr<Vector<Region*, 2>> AddressSpace::try_split_region_around_range(const Region& source_region, VirtualRange const& desired_range)
+ErrorOr<Vector<Region*, 2>> AddressSpace::try_split_region_around_range(const Region& source_region, VirtualRange const& desired_range)
 {
     VirtualRange old_region_range = source_region.range();
     auto remaining_ranges_after_unmap = old_region_range.carve(desired_range);
 
     VERIFY(!remaining_ranges_after_unmap.is_empty());
-    auto try_make_replacement_region = [&](VirtualRange const& new_range) -> KResultOr<Region*> {
+    auto try_make_replacement_region = [&](VirtualRange const& new_range) -> ErrorOr<Region*> {
         VERIFY(old_region_range.contains(new_range));
         size_t new_range_offset_in_vmobject = source_region.offset_in_vmobject() + (new_range.base().get() - old_region_range.base().get());
         return try_allocate_split_region(source_region, new_range, new_range_offset_in_vmobject);
diff --git a/Kernel/Memory/AddressSpace.h b/Kernel/Memory/AddressSpace.h
index 9617a54b1d8..5a96e0abb0c 100644
--- a/Kernel/Memory/AddressSpace.h
+++ b/Kernel/Memory/AddressSpace.h
@@ -18,13 +18,13 @@ namespace Kernel::Memory {
 
 class AddressSpace {
 public:
-    static KResultOr<NonnullOwnPtr<AddressSpace>> try_create(AddressSpace const* parent);
+    static ErrorOr<NonnullOwnPtr<AddressSpace>> try_create(AddressSpace const* parent);
     ~AddressSpace();
 
     PageDirectory& page_directory() { return *m_page_directory; }
     const PageDirectory& page_directory() const { return *m_page_directory; }
 
-    KResultOr<Region*> add_region(NonnullOwnPtr<Region>);
+    ErrorOr<Region*> add_region(NonnullOwnPtr<Region>);
 
     size_t region_count() const { return m_regions.size(); }
 
@@ -33,17 +33,17 @@ public:
 
     void dump_regions();
 
-    KResult unmap_mmap_range(VirtualAddress, size_t);
+    ErrorOr<void> unmap_mmap_range(VirtualAddress, size_t);
 
-    KResultOr<VirtualRange> try_allocate_range(VirtualAddress, size_t, size_t alignment = PAGE_SIZE);
+    ErrorOr<VirtualRange> try_allocate_range(VirtualAddress, size_t, size_t alignment = PAGE_SIZE);
 
-    KResultOr<Region*> allocate_region_with_vmobject(VirtualRange const&, NonnullRefPtr<VMObject>, size_t offset_in_vmobject, StringView name, int prot, bool shared);
-    KResultOr<Region*> allocate_region(VirtualRange const&, StringView name, int prot = PROT_READ | PROT_WRITE, AllocationStrategy strategy = AllocationStrategy::Reserve);
+    ErrorOr<Region*> allocate_region_with_vmobject(VirtualRange const&, NonnullRefPtr<VMObject>, size_t offset_in_vmobject, StringView name, int prot, bool shared);
+    ErrorOr<Region*> allocate_region(VirtualRange const&, StringView name, int prot = PROT_READ | PROT_WRITE, AllocationStrategy strategy = AllocationStrategy::Reserve);
     void deallocate_region(Region& region);
     NonnullOwnPtr<Region> take_region(Region& region);
 
-    KResultOr<Region*> try_allocate_split_region(Region const& source_region, VirtualRange const&, size_t offset_in_vmobject);
-    KResultOr<Vector<Region*, 2>> try_split_region_around_range(Region const& source_region, VirtualRange const&);
+    ErrorOr<Region*> try_allocate_split_region(Region const& source_region, VirtualRange const&, size_t offset_in_vmobject);
+    ErrorOr<Vector<Region*, 2>> try_split_region_around_range(Region const& source_region, VirtualRange const&);
 
     Region* find_region_from_range(VirtualRange const&);
     Region* find_region_containing(VirtualRange const&);
diff --git a/Kernel/Memory/AnonymousVMObject.cpp b/Kernel/Memory/AnonymousVMObject.cpp
index 582f3192ee5..9650f4b99e3 100644
--- a/Kernel/Memory/AnonymousVMObject.cpp
+++ b/Kernel/Memory/AnonymousVMObject.cpp
@@ -13,7 +13,7 @@
 
 namespace Kernel::Memory {
 
-KResultOr<NonnullRefPtr<VMObject>> AnonymousVMObject::try_clone()
+ErrorOr<NonnullRefPtr<VMObject>> AnonymousVMObject::try_clone()
 {
     // We need to acquire our lock so we copy a sane state
     SpinlockLocker lock(m_lock);
@@ -66,7 +66,7 @@ KResultOr<NonnullRefPtr<VMObject>> AnonymousVMObject::try_clone()
     return clone;
 }
 
-KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_with_size(size_t size, AllocationStrategy strategy)
+ErrorOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_with_size(size_t size, AllocationStrategy strategy)
 {
     Optional<CommittedPhysicalPageSet> committed_pages;
     if (strategy == AllocationStrategy::Reserve || strategy == AllocationStrategy::AllocateNow) {
@@ -76,7 +76,7 @@ KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_with_s
     return adopt_nonnull_ref_or_enomem(new (nothrow) AnonymousVMObject(size, strategy, move(committed_pages)));
 }
 
-KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_physically_contiguous_with_size(size_t size)
+ErrorOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_physically_contiguous_with_size(size_t size)
 {
     auto contiguous_physical_pages = MM.allocate_contiguous_supervisor_physical_pages(size);
     if (contiguous_physical_pages.is_empty())
@@ -85,7 +85,7 @@ KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_physic
     return adopt_nonnull_ref_or_enomem(new (nothrow) AnonymousVMObject(contiguous_physical_pages.span()));
 }
 
-KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_purgeable_with_size(size_t size, AllocationStrategy strategy)
+ErrorOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_purgeable_with_size(size_t size, AllocationStrategy strategy)
 {
     Optional<CommittedPhysicalPageSet> committed_pages;
     if (strategy == AllocationStrategy::Reserve || strategy == AllocationStrategy::AllocateNow) {
@@ -97,12 +97,12 @@ KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_purgea
     return vmobject;
 }
 
-KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_with_physical_pages(Span<NonnullRefPtr<PhysicalPage>> physical_pages)
+ErrorOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_with_physical_pages(Span<NonnullRefPtr<PhysicalPage>> physical_pages)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) AnonymousVMObject(physical_pages));
 }
 
-KResultOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_for_physical_range(PhysicalAddress paddr, size_t size)
+ErrorOr<NonnullRefPtr<AnonymousVMObject>> AnonymousVMObject::try_create_for_physical_range(PhysicalAddress paddr, size_t size)
 {
     if (paddr.offset(size) < paddr) {
         dbgln("Shenanigans! try_create_for_physical_range({}, {}) would wrap around", paddr, size);
@@ -182,7 +182,7 @@ size_t AnonymousVMObject::purge()
     return total_pages_purged;
 }
 
-KResult AnonymousVMObject::set_volatile(bool is_volatile, bool& was_purged)
+ErrorOr<void> AnonymousVMObject::set_volatile(bool is_volatile, bool& was_purged)
 {
     VERIFY(is_purgeable());
 
@@ -190,7 +190,7 @@ KResult AnonymousVMObject::set_volatile(bool is_volatile, bool& was_purged)
 
     was_purged = m_was_purged;
     if (m_volatile == is_volatile)
-        return KSuccess;
+        return {};
 
     if (is_volatile) {
         // When a VMObject is made volatile, it gives up all of its committed memory.
@@ -210,7 +210,7 @@ KResult AnonymousVMObject::set_volatile(bool is_volatile, bool& was_purged)
         m_was_purged = false;
 
         for_each_region([&](auto& region) { region.remap(); });
-        return KSuccess;
+        return {};
     }
     // When a VMObject is made non-volatile, we try to commit however many pages are not currently available.
     // If that fails, we return false to indicate that memory allocation failed.
@@ -223,7 +223,7 @@ KResult AnonymousVMObject::set_volatile(bool is_volatile, bool& was_purged)
 
     if (!committed_pages_needed) {
         m_volatile = false;
-        return KSuccess;
+        return {};
     }
 
     m_unused_committed_pages = TRY(MM.commit_user_physical_pages(committed_pages_needed));
@@ -236,7 +236,7 @@ KResult AnonymousVMObject::set_volatile(bool is_volatile, bool& was_purged)
     m_volatile = false;
     m_was_purged = false;
     for_each_region([&](auto& region) { region.remap(); });
-    return KSuccess;
+    return {};
 }
 
 NonnullRefPtr<PhysicalPage> AnonymousVMObject::allocate_committed_page(Badge<Region>)
diff --git a/Kernel/Memory/AnonymousVMObject.h b/Kernel/Memory/AnonymousVMObject.h
index f0b308a3be8..b645b4d1385 100644
--- a/Kernel/Memory/AnonymousVMObject.h
+++ b/Kernel/Memory/AnonymousVMObject.h
@@ -18,12 +18,12 @@ class AnonymousVMObject final : public VMObject {
 public:
     virtual ~AnonymousVMObject() override;
 
-    static KResultOr<NonnullRefPtr<AnonymousVMObject>> try_create_with_size(size_t, AllocationStrategy);
-    static KResultOr<NonnullRefPtr<AnonymousVMObject>> try_create_for_physical_range(PhysicalAddress paddr, size_t size);
-    static KResultOr<NonnullRefPtr<AnonymousVMObject>> try_create_with_physical_pages(Span<NonnullRefPtr<PhysicalPage>>);
-    static KResultOr<NonnullRefPtr<AnonymousVMObject>> try_create_purgeable_with_size(size_t, AllocationStrategy);
-    static KResultOr<NonnullRefPtr<AnonymousVMObject>> try_create_physically_contiguous_with_size(size_t);
-    virtual KResultOr<NonnullRefPtr<VMObject>> try_clone() override;
+    static ErrorOr<NonnullRefPtr<AnonymousVMObject>> try_create_with_size(size_t, AllocationStrategy);
+    static ErrorOr<NonnullRefPtr<AnonymousVMObject>> try_create_for_physical_range(PhysicalAddress paddr, size_t size);
+    static ErrorOr<NonnullRefPtr<AnonymousVMObject>> try_create_with_physical_pages(Span<NonnullRefPtr<PhysicalPage>>);
+    static ErrorOr<NonnullRefPtr<AnonymousVMObject>> try_create_purgeable_with_size(size_t, AllocationStrategy);
+    static ErrorOr<NonnullRefPtr<AnonymousVMObject>> try_create_physically_contiguous_with_size(size_t);
+    virtual ErrorOr<NonnullRefPtr<VMObject>> try_clone() override;
 
     [[nodiscard]] NonnullRefPtr<PhysicalPage> allocate_committed_page(Badge<Region>);
     PageFaultResponse handle_cow_fault(size_t, VirtualAddress);
@@ -34,7 +34,7 @@ public:
     bool is_purgeable() const { return m_purgeable; }
     bool is_volatile() const { return m_volatile; }
 
-    KResult set_volatile(bool is_volatile, bool& was_purged);
+    ErrorOr<void> set_volatile(bool is_volatile, bool& was_purged);
 
     size_t purge();
 
diff --git a/Kernel/Memory/MemoryManager.cpp b/Kernel/Memory/MemoryManager.cpp
index 377cea04caf..2a5afa36887 100644
--- a/Kernel/Memory/MemoryManager.cpp
+++ b/Kernel/Memory/MemoryManager.cpp
@@ -705,7 +705,7 @@ PageFaultResponse MemoryManager::handle_page_fault(PageFault const& fault)
     return region->handle_fault(fault);
 }
 
-KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_contiguous_kernel_region(size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
+ErrorOr<NonnullOwnPtr<Region>> MemoryManager::allocate_contiguous_kernel_region(size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
 {
     VERIFY(!(size % PAGE_SIZE));
     SpinlockLocker lock(kernel_page_directory().get_lock());
@@ -714,7 +714,7 @@ KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_contiguous_kernel_regio
     return allocate_kernel_region_with_vmobject(range, move(vmobject), name, access, cacheable);
 }
 
-KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region(size_t size, StringView name, Region::Access access, AllocationStrategy strategy, Region::Cacheable cacheable)
+ErrorOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region(size_t size, StringView name, Region::Access access, AllocationStrategy strategy, Region::Cacheable cacheable)
 {
     VERIFY(!(size % PAGE_SIZE));
     auto vmobject = TRY(AnonymousVMObject::try_create_with_size(size, strategy));
@@ -723,7 +723,7 @@ KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region(size_t si
     return allocate_kernel_region_with_vmobject(range, move(vmobject), name, access, cacheable);
 }
 
-KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region(PhysicalAddress paddr, size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
+ErrorOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region(PhysicalAddress paddr, size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
 {
     VERIFY(!(size % PAGE_SIZE));
     auto vmobject = TRY(AnonymousVMObject::try_create_for_physical_range(paddr, size));
@@ -732,7 +732,7 @@ KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region(PhysicalA
     return allocate_kernel_region_with_vmobject(range, move(vmobject), name, access, cacheable);
 }
 
-KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region_with_vmobject(VirtualRange const& range, VMObject& vmobject, StringView name, Region::Access access, Region::Cacheable cacheable)
+ErrorOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region_with_vmobject(VirtualRange const& range, VMObject& vmobject, StringView name, Region::Access access, Region::Cacheable cacheable)
 {
     OwnPtr<KString> name_kstring;
     if (!name.is_null())
@@ -742,7 +742,7 @@ KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region_with_vmob
     return region;
 }
 
-KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region_with_vmobject(VMObject& vmobject, size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
+ErrorOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region_with_vmobject(VMObject& vmobject, size_t size, StringView name, Region::Access access, Region::Cacheable cacheable)
 {
     VERIFY(!(size % PAGE_SIZE));
     SpinlockLocker lock(kernel_page_directory().get_lock());
@@ -750,7 +750,7 @@ KResultOr<NonnullOwnPtr<Region>> MemoryManager::allocate_kernel_region_with_vmob
     return allocate_kernel_region_with_vmobject(range, vmobject, name, access, cacheable);
 }
 
-KResultOr<CommittedPhysicalPageSet> MemoryManager::commit_user_physical_pages(size_t page_count)
+ErrorOr<CommittedPhysicalPageSet> MemoryManager::commit_user_physical_pages(size_t page_count)
 {
     VERIFY(page_count > 0);
     SpinlockLocker lock(s_mm_lock);
diff --git a/Kernel/Memory/MemoryManager.h b/Kernel/Memory/MemoryManager.h
index 9309ad02fae..13380820b56 100644
--- a/Kernel/Memory/MemoryManager.h
+++ b/Kernel/Memory/MemoryManager.h
@@ -171,7 +171,7 @@ public:
         Yes
     };
 
-    KResultOr<CommittedPhysicalPageSet> commit_user_physical_pages(size_t page_count);
+    ErrorOr<CommittedPhysicalPageSet> commit_user_physical_pages(size_t page_count);
     void uncommit_user_physical_pages(Badge<CommittedPhysicalPageSet>, size_t page_count);
 
     NonnullRefPtr<PhysicalPage> allocate_committed_user_physical_page(Badge<CommittedPhysicalPageSet>, ShouldZeroFill = ShouldZeroFill::Yes);
@@ -180,11 +180,11 @@ public:
     NonnullRefPtrVector<PhysicalPage> allocate_contiguous_supervisor_physical_pages(size_t size);
     void deallocate_physical_page(PhysicalAddress);
 
-    KResultOr<NonnullOwnPtr<Region>> allocate_contiguous_kernel_region(size_t, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
-    KResultOr<NonnullOwnPtr<Region>> allocate_kernel_region(size_t, StringView name, Region::Access access, AllocationStrategy strategy = AllocationStrategy::Reserve, Region::Cacheable = Region::Cacheable::Yes);
-    KResultOr<NonnullOwnPtr<Region>> allocate_kernel_region(PhysicalAddress, size_t, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
-    KResultOr<NonnullOwnPtr<Region>> allocate_kernel_region_with_vmobject(VMObject&, size_t, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
-    KResultOr<NonnullOwnPtr<Region>> allocate_kernel_region_with_vmobject(VirtualRange const&, VMObject&, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
+    ErrorOr<NonnullOwnPtr<Region>> allocate_contiguous_kernel_region(size_t, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
+    ErrorOr<NonnullOwnPtr<Region>> allocate_kernel_region(size_t, StringView name, Region::Access access, AllocationStrategy strategy = AllocationStrategy::Reserve, Region::Cacheable = Region::Cacheable::Yes);
+    ErrorOr<NonnullOwnPtr<Region>> allocate_kernel_region(PhysicalAddress, size_t, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
+    ErrorOr<NonnullOwnPtr<Region>> allocate_kernel_region_with_vmobject(VMObject&, size_t, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
+    ErrorOr<NonnullOwnPtr<Region>> allocate_kernel_region_with_vmobject(VirtualRange const&, VMObject&, StringView name, Region::Access access, Region::Cacheable = Region::Cacheable::Yes);
 
     struct SystemMemoryInfo {
         PhysicalSize user_physical_pages { 0 };
diff --git a/Kernel/Memory/PageDirectory.cpp b/Kernel/Memory/PageDirectory.cpp
index e277e634547..4461a294bef 100644
--- a/Kernel/Memory/PageDirectory.cpp
+++ b/Kernel/Memory/PageDirectory.cpp
@@ -42,7 +42,7 @@ UNMAP_AFTER_INIT NonnullRefPtr<PageDirectory> PageDirectory::must_create_kernel_
     return directory;
 }
 
-KResultOr<NonnullRefPtr<PageDirectory>> PageDirectory::try_create_for_userspace(VirtualRangeAllocator const* parent_range_allocator)
+ErrorOr<NonnullRefPtr<PageDirectory>> PageDirectory::try_create_for_userspace(VirtualRangeAllocator const* parent_range_allocator)
 {
     constexpr FlatPtr userspace_range_base = 0x00800000;
     FlatPtr const userspace_range_ceiling = USER_RANGE_CEILING;
diff --git a/Kernel/Memory/PageDirectory.h b/Kernel/Memory/PageDirectory.h
index d1755f4f1c5..125dd81f708 100644
--- a/Kernel/Memory/PageDirectory.h
+++ b/Kernel/Memory/PageDirectory.h
@@ -20,7 +20,7 @@ class PageDirectory : public RefCounted<PageDirectory> {
     friend class MemoryManager;
 
 public:
-    static KResultOr<NonnullRefPtr<PageDirectory>> try_create_for_userspace(VirtualRangeAllocator const* parent_range_allocator = nullptr);
+    static ErrorOr<NonnullRefPtr<PageDirectory>> try_create_for_userspace(VirtualRangeAllocator const* parent_range_allocator = nullptr);
     static NonnullRefPtr<PageDirectory> must_create_kernel_page_directory();
     static RefPtr<PageDirectory> find_by_cr3(FlatPtr);
 
diff --git a/Kernel/Memory/PrivateInodeVMObject.cpp b/Kernel/Memory/PrivateInodeVMObject.cpp
index 25b1b6cbad0..cd552bc34f8 100644
--- a/Kernel/Memory/PrivateInodeVMObject.cpp
+++ b/Kernel/Memory/PrivateInodeVMObject.cpp
@@ -9,12 +9,12 @@
 
 namespace Kernel::Memory {
 
-KResultOr<NonnullRefPtr<PrivateInodeVMObject>> PrivateInodeVMObject::try_create_with_inode(Inode& inode)
+ErrorOr<NonnullRefPtr<PrivateInodeVMObject>> PrivateInodeVMObject::try_create_with_inode(Inode& inode)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) PrivateInodeVMObject(inode, inode.size()));
 }
 
-KResultOr<NonnullRefPtr<VMObject>> PrivateInodeVMObject::try_clone()
+ErrorOr<NonnullRefPtr<VMObject>> PrivateInodeVMObject::try_clone()
 {
     return adopt_nonnull_ref_or_enomem<VMObject>(new (nothrow) PrivateInodeVMObject(*this));
 }
diff --git a/Kernel/Memory/PrivateInodeVMObject.h b/Kernel/Memory/PrivateInodeVMObject.h
index 96a2f67fb7a..2f6d8598e9e 100644
--- a/Kernel/Memory/PrivateInodeVMObject.h
+++ b/Kernel/Memory/PrivateInodeVMObject.h
@@ -18,8 +18,8 @@ class PrivateInodeVMObject final : public InodeVMObject {
 public:
     virtual ~PrivateInodeVMObject() override;
 
-    static KResultOr<NonnullRefPtr<PrivateInodeVMObject>> try_create_with_inode(Inode&);
-    virtual KResultOr<NonnullRefPtr<VMObject>> try_clone() override;
+    static ErrorOr<NonnullRefPtr<PrivateInodeVMObject>> try_create_with_inode(Inode&);
+    virtual ErrorOr<NonnullRefPtr<VMObject>> try_clone() override;
 
 private:
     virtual bool is_private_inode() const override { return true; }
diff --git a/Kernel/Memory/Region.cpp b/Kernel/Memory/Region.cpp
index 534909c035c..b757ffee9e6 100644
--- a/Kernel/Memory/Region.cpp
+++ b/Kernel/Memory/Region.cpp
@@ -50,7 +50,7 @@ Region::~Region()
     }
 }
 
-KResultOr<NonnullOwnPtr<Region>> Region::try_clone()
+ErrorOr<NonnullOwnPtr<Region>> Region::try_clone()
 {
     VERIFY(Process::has_current());
 
@@ -144,12 +144,12 @@ size_t Region::amount_shared() const
     return bytes;
 }
 
-KResultOr<NonnullOwnPtr<Region>> Region::try_create_user_accessible(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable, bool shared)
+ErrorOr<NonnullOwnPtr<Region>> Region::try_create_user_accessible(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable, bool shared)
 {
     return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, shared));
 }
 
-KResultOr<NonnullOwnPtr<Region>> Region::try_create_kernel_only(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable)
+ErrorOr<NonnullOwnPtr<Region>> Region::try_create_kernel_only(VirtualRange const& range, NonnullRefPtr<VMObject> vmobject, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable cacheable)
 {
     return adopt_nonnull_own_or_enomem(new (nothrow) Region(range, move(vmobject), offset_in_vmobject, move(name), access, cacheable, false));
 }
@@ -253,7 +253,7 @@ void Region::set_page_directory(PageDirectory& page_directory)
     m_page_directory = page_directory;
 }
 
-KResult Region::map(PageDirectory& page_directory, ShouldFlushTLB should_flush_tlb)
+ErrorOr<void> Region::map(PageDirectory& page_directory, ShouldFlushTLB should_flush_tlb)
 {
     SpinlockLocker page_lock(page_directory.get_lock());
     SpinlockLocker lock(s_mm_lock);
@@ -274,7 +274,7 @@ KResult Region::map(PageDirectory& page_directory, ShouldFlushTLB should_flush_t
         if (should_flush_tlb == ShouldFlushTLB::Yes)
             MemoryManager::flush_tlb(m_page_directory, vaddr(), page_index);
         if (page_index == page_count())
-            return KSuccess;
+            return {};
     }
     return ENOMEM;
 }
diff --git a/Kernel/Memory/Region.h b/Kernel/Memory/Region.h
index 1b02cf6d127..80bb799fcfb 100644
--- a/Kernel/Memory/Region.h
+++ b/Kernel/Memory/Region.h
@@ -49,8 +49,8 @@ public:
         Yes,
     };
 
-    static KResultOr<NonnullOwnPtr<Region>> try_create_user_accessible(VirtualRange const&, NonnullRefPtr<VMObject>, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable, bool shared);
-    static KResultOr<NonnullOwnPtr<Region>> try_create_kernel_only(VirtualRange const&, NonnullRefPtr<VMObject>, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable = Cacheable::Yes);
+    static ErrorOr<NonnullOwnPtr<Region>> try_create_user_accessible(VirtualRange const&, NonnullRefPtr<VMObject>, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable, bool shared);
+    static ErrorOr<NonnullOwnPtr<Region>> try_create_kernel_only(VirtualRange const&, NonnullRefPtr<VMObject>, size_t offset_in_vmobject, OwnPtr<KString> name, Region::Access access, Cacheable = Cacheable::Yes);
 
     ~Region();
 
@@ -90,7 +90,7 @@ public:
 
     PageFaultResponse handle_fault(PageFault const&);
 
-    KResultOr<NonnullOwnPtr<Region>> try_clone();
+    ErrorOr<NonnullOwnPtr<Region>> try_clone();
 
     [[nodiscard]] bool contains(VirtualAddress vaddr) const
     {
@@ -170,7 +170,7 @@ public:
     void set_executable(bool b) { set_access_bit(Access::Execute, b); }
 
     void set_page_directory(PageDirectory&);
-    KResult map(PageDirectory&, ShouldFlushTLB = ShouldFlushTLB::Yes);
+    ErrorOr<void> map(PageDirectory&, ShouldFlushTLB = ShouldFlushTLB::Yes);
     enum class ShouldDeallocateVirtualRange {
         No,
         Yes,
diff --git a/Kernel/Memory/RingBuffer.cpp b/Kernel/Memory/RingBuffer.cpp
index 06d2da02ff7..a807d0aa931 100644
--- a/Kernel/Memory/RingBuffer.cpp
+++ b/Kernel/Memory/RingBuffer.cpp
@@ -29,7 +29,7 @@ bool RingBuffer::copy_data_in(const UserOrKernelBuffer& buffer, size_t offset, s
     return true;
 }
 
-KResultOr<size_t> RingBuffer::copy_data_out(size_t size, UserOrKernelBuffer& buffer) const
+ErrorOr<size_t> RingBuffer::copy_data_out(size_t size, UserOrKernelBuffer& buffer) const
 {
     auto start = m_start_of_used % m_capacity_in_bytes;
     auto num_bytes = min(min(m_num_used_bytes, size), m_capacity_in_bytes - start);
@@ -37,7 +37,7 @@ KResultOr<size_t> RingBuffer::copy_data_out(size_t size, UserOrKernelBuffer& buf
     return num_bytes;
 }
 
-KResultOr<PhysicalAddress> RingBuffer::reserve_space(size_t size)
+ErrorOr<PhysicalAddress> RingBuffer::reserve_space(size_t size)
 {
     if (m_capacity_in_bytes < m_num_used_bytes + size)
         return ENOSPC;
diff --git a/Kernel/Memory/RingBuffer.h b/Kernel/Memory/RingBuffer.h
index 45338c51f05..7b8889f64aa 100644
--- a/Kernel/Memory/RingBuffer.h
+++ b/Kernel/Memory/RingBuffer.h
@@ -18,8 +18,8 @@ public:
 
     bool has_space() const { return m_num_used_bytes < m_capacity_in_bytes; }
     bool copy_data_in(const UserOrKernelBuffer& buffer, size_t offset, size_t length, PhysicalAddress& start_of_copied_data, size_t& bytes_copied);
-    KResultOr<size_t> copy_data_out(size_t size, UserOrKernelBuffer& buffer) const;
-    KResultOr<PhysicalAddress> reserve_space(size_t size);
+    ErrorOr<size_t> copy_data_out(size_t size, UserOrKernelBuffer& buffer) const;
+    ErrorOr<PhysicalAddress> reserve_space(size_t size);
     void reclaim_space(PhysicalAddress chunk_start, size_t chunk_size);
     PhysicalAddress start_of_used() const;
 
diff --git a/Kernel/Memory/ScatterGatherList.cpp b/Kernel/Memory/ScatterGatherList.cpp
index 1f4cd530af2..803b0c15f8a 100644
--- a/Kernel/Memory/ScatterGatherList.cpp
+++ b/Kernel/Memory/ScatterGatherList.cpp
@@ -12,7 +12,7 @@ RefPtr<ScatterGatherList> ScatterGatherList::try_create(AsyncBlockDeviceRequest&
 {
     auto maybe_vm_object = AnonymousVMObject::try_create_with_physical_pages(allocated_pages);
     if (maybe_vm_object.is_error()) {
-        // FIXME: Would be nice to be able to return a KResultOr here.
+        // FIXME: Would be nice to be able to return a ErrorOr here.
         return {};
     }
     return adopt_ref_if_nonnull(new (nothrow) ScatterGatherList(maybe_vm_object.release_value(), request, device_block_size));
diff --git a/Kernel/Memory/SharedInodeVMObject.cpp b/Kernel/Memory/SharedInodeVMObject.cpp
index 7dacfd6e66f..605af54e181 100644
--- a/Kernel/Memory/SharedInodeVMObject.cpp
+++ b/Kernel/Memory/SharedInodeVMObject.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel::Memory {
 
-KResultOr<NonnullRefPtr<SharedInodeVMObject>> SharedInodeVMObject::try_create_with_inode(Inode& inode)
+ErrorOr<NonnullRefPtr<SharedInodeVMObject>> SharedInodeVMObject::try_create_with_inode(Inode& inode)
 {
     size_t size = inode.size();
     if (auto shared_vmobject = inode.shared_vmobject())
@@ -19,7 +19,7 @@ KResultOr<NonnullRefPtr<SharedInodeVMObject>> SharedInodeVMObject::try_create_wi
     return vmobject;
 }
 
-KResultOr<NonnullRefPtr<VMObject>> SharedInodeVMObject::try_clone()
+ErrorOr<NonnullRefPtr<VMObject>> SharedInodeVMObject::try_clone()
 {
     return adopt_nonnull_ref_or_enomem<VMObject>(new (nothrow) SharedInodeVMObject(*this));
 }
diff --git a/Kernel/Memory/SharedInodeVMObject.h b/Kernel/Memory/SharedInodeVMObject.h
index 5b91785c55c..b6fea408b5d 100644
--- a/Kernel/Memory/SharedInodeVMObject.h
+++ b/Kernel/Memory/SharedInodeVMObject.h
@@ -16,8 +16,8 @@ class SharedInodeVMObject final : public InodeVMObject {
     AK_MAKE_NONMOVABLE(SharedInodeVMObject);
 
 public:
-    static KResultOr<NonnullRefPtr<SharedInodeVMObject>> try_create_with_inode(Inode&);
-    virtual KResultOr<NonnullRefPtr<VMObject>> try_clone() override;
+    static ErrorOr<NonnullRefPtr<SharedInodeVMObject>> try_create_with_inode(Inode&);
+    virtual ErrorOr<NonnullRefPtr<VMObject>> try_clone() override;
 
 private:
     virtual bool is_shared_inode() const override { return true; }
diff --git a/Kernel/Memory/VMObject.h b/Kernel/Memory/VMObject.h
index e6079dd22bb..2cfa03f8aa9 100644
--- a/Kernel/Memory/VMObject.h
+++ b/Kernel/Memory/VMObject.h
@@ -26,7 +26,7 @@ class VMObject
 public:
     virtual ~VMObject();
 
-    virtual KResultOr<NonnullRefPtr<VMObject>> try_clone() = 0;
+    virtual ErrorOr<NonnullRefPtr<VMObject>> try_clone() = 0;
 
     virtual bool is_anonymous() const { return false; }
     virtual bool is_inode() const { return false; }
diff --git a/Kernel/Memory/VirtualRange.cpp b/Kernel/Memory/VirtualRange.cpp
index c049ddf1bc6..06d5b040a65 100644
--- a/Kernel/Memory/VirtualRange.cpp
+++ b/Kernel/Memory/VirtualRange.cpp
@@ -36,7 +36,7 @@ VirtualRange VirtualRange::intersect(VirtualRange const& other) const
     return VirtualRange(new_base, (new_end - new_base).get());
 }
 
-KResultOr<VirtualRange> VirtualRange::expand_to_page_boundaries(FlatPtr address, size_t size)
+ErrorOr<VirtualRange> VirtualRange::expand_to_page_boundaries(FlatPtr address, size_t size)
 {
     if (page_round_up_would_wrap(size))
         return EINVAL;
diff --git a/Kernel/Memory/VirtualRange.h b/Kernel/Memory/VirtualRange.h
index cad0b04a647..93c8f80df3f 100644
--- a/Kernel/Memory/VirtualRange.h
+++ b/Kernel/Memory/VirtualRange.h
@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <Kernel/API/KResult.h>
+#include <AK/Error.h>
 #include <Kernel/VirtualAddress.h>
 
 namespace Kernel::Memory {
@@ -51,7 +51,7 @@ public:
     Vector<VirtualRange, 2> carve(VirtualRange const&) const;
     VirtualRange intersect(VirtualRange const&) const;
 
-    static KResultOr<VirtualRange> expand_to_page_boundaries(FlatPtr address, size_t size);
+    static ErrorOr<VirtualRange> expand_to_page_boundaries(FlatPtr address, size_t size);
 
 private:
     VirtualAddress m_base;
diff --git a/Kernel/Memory/VirtualRangeAllocator.cpp b/Kernel/Memory/VirtualRangeAllocator.cpp
index 02389c8e1b9..b9cbdf154d8 100644
--- a/Kernel/Memory/VirtualRangeAllocator.cpp
+++ b/Kernel/Memory/VirtualRangeAllocator.cpp
@@ -56,7 +56,7 @@ void VirtualRangeAllocator::carve_from_region(VirtualRange const& from, VirtualR
     }
 }
 
-KResultOr<VirtualRange> VirtualRangeAllocator::try_allocate_randomized(size_t size, size_t alignment)
+ErrorOr<VirtualRange> VirtualRangeAllocator::try_allocate_randomized(size_t size, size_t alignment)
 {
     if (!size)
         return EINVAL;
@@ -80,7 +80,7 @@ KResultOr<VirtualRange> VirtualRangeAllocator::try_allocate_randomized(size_t si
     return try_allocate_anywhere(size, alignment);
 }
 
-KResultOr<VirtualRange> VirtualRangeAllocator::try_allocate_anywhere(size_t size, size_t alignment)
+ErrorOr<VirtualRange> VirtualRangeAllocator::try_allocate_anywhere(size_t size, size_t alignment)
 {
     if (!size)
         return EINVAL;
@@ -129,7 +129,7 @@ KResultOr<VirtualRange> VirtualRangeAllocator::try_allocate_anywhere(size_t size
     return ENOMEM;
 }
 
-KResultOr<VirtualRange> VirtualRangeAllocator::try_allocate_specific(VirtualAddress base, size_t size)
+ErrorOr<VirtualRange> VirtualRangeAllocator::try_allocate_specific(VirtualAddress base, size_t size)
 {
     if (!size)
         return EINVAL;
diff --git a/Kernel/Memory/VirtualRangeAllocator.h b/Kernel/Memory/VirtualRangeAllocator.h
index 9a62b001946..c09202e1653 100644
--- a/Kernel/Memory/VirtualRangeAllocator.h
+++ b/Kernel/Memory/VirtualRangeAllocator.h
@@ -21,9 +21,9 @@ public:
     void initialize_with_range(VirtualAddress, size_t);
     void initialize_from_parent(VirtualRangeAllocator const&);
 
-    KResultOr<VirtualRange> try_allocate_anywhere(size_t, size_t alignment = PAGE_SIZE);
-    KResultOr<VirtualRange> try_allocate_specific(VirtualAddress, size_t);
-    KResultOr<VirtualRange> try_allocate_randomized(size_t, size_t alignment);
+    ErrorOr<VirtualRange> try_allocate_anywhere(size_t, size_t alignment = PAGE_SIZE);
+    ErrorOr<VirtualRange> try_allocate_specific(VirtualAddress, size_t);
+    ErrorOr<VirtualRange> try_allocate_randomized(size_t, size_t alignment);
     void deallocate(VirtualRange const&);
 
     void dump() const;
diff --git a/Kernel/Net/IPv4Socket.cpp b/Kernel/Net/IPv4Socket.cpp
index 9eaebce4370..dfb84a474fb 100644
--- a/Kernel/Net/IPv4Socket.cpp
+++ b/Kernel/Net/IPv4Socket.cpp
@@ -35,12 +35,12 @@ MutexProtected<IPv4Socket::List>& IPv4Socket::all_sockets()
     return *s_all_sockets;
 }
 
-KResultOr<NonnullOwnPtr<DoubleBuffer>> IPv4Socket::try_create_receive_buffer()
+ErrorOr<NonnullOwnPtr<DoubleBuffer>> IPv4Socket::try_create_receive_buffer()
 {
     return DoubleBuffer::try_create(256 * KiB);
 }
 
-KResultOr<NonnullRefPtr<Socket>> IPv4Socket::create(int type, int protocol)
+ErrorOr<NonnullRefPtr<Socket>> IPv4Socket::create(int type, int protocol)
 {
     auto receive_buffer = TRY(IPv4Socket::try_create_receive_buffer());
 
@@ -94,7 +94,7 @@ void IPv4Socket::get_peer_address(sockaddr* address, socklen_t* address_size)
     *address_size = sizeof(sockaddr_in);
 }
 
-KResult IPv4Socket::bind(Userspace<const sockaddr*> user_address, socklen_t address_size)
+ErrorOr<void> IPv4Socket::bind(Userspace<const sockaddr*> user_address, socklen_t address_size)
 {
     VERIFY(setup_state() == SetupState::Unstarted);
     if (address_size != sizeof(sockaddr_in))
@@ -122,12 +122,12 @@ KResult IPv4Socket::bind(Userspace<const sockaddr*> user_address, socklen_t addr
     return protocol_bind();
 }
 
-KResult IPv4Socket::listen(size_t backlog)
+ErrorOr<void> IPv4Socket::listen(size_t backlog)
 {
     MutexLocker locker(mutex());
     auto result = allocate_local_port_if_needed();
-    if (result.error_or_port.is_error() && result.error_or_port.error() != ENOPROTOOPT)
-        return result.error_or_port.error();
+    if (result.error_or_port.is_error() && result.error_or_port.error().code() != ENOPROTOOPT)
+        return result.error_or_port.release_error();
 
     set_backlog(backlog);
     set_role(Role::Listener);
@@ -138,7 +138,7 @@ KResult IPv4Socket::listen(size_t backlog)
     return protocol_listen(result.did_allocate);
 }
 
-KResult IPv4Socket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock should_block)
+ErrorOr<void> IPv4Socket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock should_block)
 {
     if (address_size != sizeof(sockaddr_in))
         return set_so_error(EINVAL);
@@ -182,12 +182,12 @@ PortAllocationResult IPv4Socket::allocate_local_port_if_needed()
         return { m_local_port, false };
     auto port_or_error = protocol_allocate_local_port();
     if (port_or_error.is_error())
-        return { port_or_error.error(), false };
-    m_local_port = port_or_error.value();
+        return { port_or_error.release_error(), false };
+    m_local_port = port_or_error.release_value();
     return { m_local_port, true };
 }
 
-KResultOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
+ErrorOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuffer& data, size_t data_length, [[maybe_unused]] int flags, Userspace<const sockaddr*> addr, socklen_t addr_length)
 {
     MutexLocker locker(mutex());
 
@@ -217,8 +217,8 @@ KResultOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuf
     if (m_local_address.to_u32() == 0)
         m_local_address = routing_decision.adapter->ipv4_address();
 
-    if (auto result = allocate_local_port_if_needed(); result.error_or_port.is_error() && result.error_or_port.error() != ENOPROTOOPT)
-        return result.error_or_port.error();
+    if (auto result = allocate_local_port_if_needed(); result.error_or_port.is_error() && result.error_or_port.error().code() != ENOPROTOOPT)
+        return result.error_or_port.release_error();
 
     dbgln_if(IPV4_SOCKET_DEBUG, "sendto: destination={}:{}", m_peer_address, m_peer_port);
 
@@ -232,7 +232,7 @@ KResultOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuf
             m_peer_address, (IPv4Protocol)protocol(), data_length, m_type_of_service, m_ttl);
         if (auto result = data.read(packet->buffer->data() + ipv4_payload_offset, data_length); result.is_error()) {
             routing_decision.adapter->release_packet_buffer(*packet);
-            return set_so_error(result);
+            return set_so_error(result.release_error());
         }
         routing_decision.adapter->send_packet(packet->bytes());
         routing_decision.adapter->release_packet_buffer(*packet);
@@ -245,7 +245,7 @@ KResultOr<size_t> IPv4Socket::sendto(OpenFileDescription&, const UserOrKernelBuf
     return nsent_or_error;
 }
 
-KResultOr<size_t> IPv4Socket::receive_byte_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>)
+ErrorOr<size_t> IPv4Socket::receive_byte_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>)
 {
     MutexLocker locker(mutex());
 
@@ -271,7 +271,7 @@ KResultOr<size_t> IPv4Socket::receive_byte_buffered(OpenFileDescription& descrip
         }
     }
 
-    KResultOr<size_t> nreceived_or_error { 0 };
+    ErrorOr<size_t> nreceived_or_error { 0 };
     if (flags & MSG_PEEK)
         nreceived_or_error = m_receive_buffer->peek(buffer, buffer_length);
     else
@@ -284,7 +284,7 @@ KResultOr<size_t> IPv4Socket::receive_byte_buffered(OpenFileDescription& descrip
     return nreceived_or_error;
 }
 
-KResultOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Time& packet_timestamp)
+ErrorOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Time& packet_timestamp)
 {
     MutexLocker locker(mutex());
     ReceivedPacket taken_packet;
@@ -379,7 +379,7 @@ KResultOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& descr
     return protocol_receive(packet->data->bytes(), buffer, buffer_length, flags);
 }
 
-KResultOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, Time& packet_timestamp)
+ErrorOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, Time& packet_timestamp)
 {
     if (user_addr_length) {
         socklen_t addr_length;
@@ -390,7 +390,7 @@ KResultOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrK
 
     dbgln_if(IPV4_SOCKET_DEBUG, "recvfrom: type={}, local_port={}", type(), local_port());
 
-    KResultOr<size_t> nreceived = 0;
+    ErrorOr<size_t> nreceived = 0;
     if (buffer_mode() == BufferMode::Bytes)
         nreceived = receive_byte_buffered(description, buffer, buffer_length, flags, user_addr, user_addr_length);
     else
@@ -456,7 +456,7 @@ bool IPv4Socket::did_receive(const IPv4Address& source_address, u16 source_port,
     return true;
 }
 
-KResultOr<NonnullOwnPtr<KString>> IPv4Socket::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> IPv4Socket::pseudo_path(const OpenFileDescription&) const
 {
     if (m_role == Role::None)
         return KString::try_create("socket"sv);
@@ -488,7 +488,7 @@ KResultOr<NonnullOwnPtr<KString>> IPv4Socket::pseudo_path(const OpenFileDescript
     return KString::try_create(builder.to_string());
 }
 
-KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> user_value, socklen_t user_value_size)
+ErrorOr<void> IPv4Socket::setsockopt(int level, int option, Userspace<const void*> user_value, socklen_t user_value_size)
 {
     if (level != IPPROTO_IP)
         return Socket::setsockopt(level, option, user_value, user_value_size);
@@ -502,7 +502,7 @@ KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> use
         if (value < 0 || value > 255)
             return EINVAL;
         m_ttl = value;
-        return KSuccess;
+        return {};
     }
     case IP_TOS: {
         if (user_value_size < sizeof(int))
@@ -512,7 +512,7 @@ KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> use
         if (value < 0 || value > 255)
             return EINVAL;
         m_type_of_service = value;
-        return KSuccess;
+        return {};
     }
     case IP_MULTICAST_LOOP: {
         if (user_value_size != 1)
@@ -522,7 +522,7 @@ KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> use
         if (value != 0 && value != 1)
             return EINVAL;
         m_multicast_loop = value;
-        return KSuccess;
+        return {};
     }
     case IP_ADD_MEMBERSHIP: {
         if (user_value_size != sizeof(ip_mreq))
@@ -534,7 +534,7 @@ KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> use
         IPv4Address address { (const u8*)&mreq.imr_multiaddr.s_addr };
         if (!m_multicast_memberships.contains_slow(address))
             m_multicast_memberships.append(address);
-        return KSuccess;
+        return {};
     }
     case IP_DROP_MEMBERSHIP: {
         if (user_value_size != sizeof(ip_mreq))
@@ -545,14 +545,14 @@ KResult IPv4Socket::setsockopt(int level, int option, Userspace<const void*> use
             return ENOTSUP;
         IPv4Address address { (const u8*)&mreq.imr_multiaddr.s_addr };
         m_multicast_memberships.remove_first_matching([&address](auto& a) { return a == address; });
-        return KSuccess;
+        return {};
     }
     default:
         return ENOPROTOOPT;
     }
 }
 
-KResult IPv4Socket::getsockopt(OpenFileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
+ErrorOr<void> IPv4Socket::getsockopt(OpenFileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
 {
     if (level != IPPROTO_IP)
         return Socket::getsockopt(description, level, option, value, value_size);
@@ -589,11 +589,11 @@ KResult IPv4Socket::getsockopt(OpenFileDescription& description, int level, int
     }
 }
 
-KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
+ErrorOr<void> IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     REQUIRE_PROMISE(inet);
 
-    auto ioctl_route = [request, arg]() -> KResult {
+    auto ioctl_route = [request, arg]() -> ErrorOr<void> {
         auto user_route = static_ptr_cast<rtentry*>(arg);
         rtentry route;
         TRY(copy_from_user(&route, user_route));
@@ -614,17 +614,17 @@ KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void
             if ((route.rt_flags & (RTF_UP | RTF_GATEWAY)) != (RTF_UP | RTF_GATEWAY))
                 return EINVAL; // FIXME: Find the correct value to return
             adapter->set_ipv4_gateway(IPv4Address(((sockaddr_in&)route.rt_gateway).sin_addr.s_addr));
-            return KSuccess;
+            return {};
 
         case SIOCDELRT:
             // FIXME: Support gateway deletion
-            return KSuccess;
+            return {};
         }
 
         return EINVAL;
     };
 
-    auto ioctl_arp = [request, arg]() -> KResult {
+    auto ioctl_arp = [request, arg]() -> ErrorOr<void> {
         auto user_req = static_ptr_cast<arpreq*>(arg);
         arpreq arp_req;
         TRY(copy_from_user(&arp_req, user_req));
@@ -636,7 +636,7 @@ KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void
             if (arp_req.arp_pa.sa_family != AF_INET)
                 return EAFNOSUPPORT;
             update_arp_table(IPv4Address(((sockaddr_in&)arp_req.arp_pa).sin_addr.s_addr), *(MACAddress*)&arp_req.arp_ha.sa_data[0], UpdateArp::Set);
-            return KSuccess;
+            return {};
 
         case SIOCDARP:
             if (!Process::current().is_superuser())
@@ -644,13 +644,13 @@ KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void
             if (arp_req.arp_pa.sa_family != AF_INET)
                 return EAFNOSUPPORT;
             update_arp_table(IPv4Address(((sockaddr_in&)arp_req.arp_pa).sin_addr.s_addr), *(MACAddress*)&arp_req.arp_ha.sa_data[0], UpdateArp::Delete);
-            return KSuccess;
+            return {};
         }
 
         return EINVAL;
     };
 
-    auto ioctl_interface = [request, arg]() -> KResult {
+    auto ioctl_interface = [request, arg]() -> ErrorOr<void> {
         auto user_ifr = static_ptr_cast<ifreq*>(arg);
         ifreq ifr;
         TRY(copy_from_user(&ifr, user_ifr));
@@ -670,7 +670,7 @@ KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void
             if (ifr.ifr_addr.sa_family != AF_INET)
                 return EAFNOSUPPORT;
             adapter->set_ipv4_address(IPv4Address(((sockaddr_in&)ifr.ifr_addr).sin_addr.s_addr));
-            return KSuccess;
+            return {};
 
         case SIOCSIFNETMASK:
             if (!Process::current().is_superuser())
@@ -678,7 +678,7 @@ KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void
             if (ifr.ifr_addr.sa_family != AF_INET)
                 return EAFNOSUPPORT;
             adapter->set_ipv4_netmask(IPv4Address(((sockaddr_in&)ifr.ifr_netmask).sin_addr.s_addr));
-            return KSuccess;
+            return {};
 
         case SIOCGIFADDR: {
             auto ip4_addr = adapter->ipv4_address().to_u32();
@@ -770,10 +770,10 @@ KResult IPv4Socket::ioctl(OpenFileDescription&, unsigned request, Userspace<void
     return EINVAL;
 }
 
-KResult IPv4Socket::close()
+ErrorOr<void> IPv4Socket::close()
 {
     [[maybe_unused]] auto rc = shutdown(SHUT_RDWR);
-    return KSuccess;
+    return {};
 }
 
 void IPv4Socket::shut_down_for_reading()
diff --git a/Kernel/Net/IPv4Socket.h b/Kernel/Net/IPv4Socket.h
index bf122114bea..6f1addbc2f3 100644
--- a/Kernel/Net/IPv4Socket.h
+++ b/Kernel/Net/IPv4Socket.h
@@ -22,29 +22,29 @@ class TCPPacket;
 class TCPSocket;
 
 struct PortAllocationResult {
-    KResultOr<u16> error_or_port;
+    ErrorOr<u16> error_or_port;
     bool did_allocate;
 };
 
 class IPv4Socket : public Socket {
 public:
-    static KResultOr<NonnullRefPtr<Socket>> create(int type, int protocol);
+    static ErrorOr<NonnullRefPtr<Socket>> create(int type, int protocol);
     virtual ~IPv4Socket() override;
 
-    virtual KResult close() override;
-    virtual KResult bind(Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResult connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
-    virtual KResult listen(size_t) override;
+    virtual ErrorOr<void> close() override;
+    virtual ErrorOr<void> bind(Userspace<const sockaddr*>, socklen_t) override;
+    virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
+    virtual ErrorOr<void> listen(size_t) override;
     virtual void get_local_address(sockaddr*, socklen_t*) override;
     virtual void get_peer_address(sockaddr*, socklen_t*) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResultOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
-    virtual KResult setsockopt(int level, int option, Userspace<const void*>, socklen_t) override;
-    virtual KResult getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
+    virtual ErrorOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
+    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
+    virtual ErrorOr<void> setsockopt(int level, int option, Userspace<const void*>, socklen_t) override;
+    virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
 
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
 
     bool did_receive(const IPv4Address& peer_address, u16 peer_port, ReadonlyBytes, const Time&);
 
@@ -61,7 +61,7 @@ public:
 
     IPv4SocketTuple tuple() const { return IPv4SocketTuple(m_local_address, m_local_port, m_peer_address, m_peer_port); }
 
-    KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription& description) const override;
+    ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription& description) const override;
 
     u8 type_of_service() const { return m_type_of_service; }
     u8 ttl() const { return m_ttl; }
@@ -78,12 +78,12 @@ protected:
 
     PortAllocationResult allocate_local_port_if_needed();
 
-    virtual KResult protocol_bind() { return KSuccess; }
-    virtual KResult protocol_listen([[maybe_unused]] bool did_allocate_port) { return KSuccess; }
-    virtual KResultOr<size_t> protocol_receive(ReadonlyBytes /* raw_ipv4_packet */, UserOrKernelBuffer&, size_t, int) { return ENOTIMPL; }
-    virtual KResultOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) { return ENOTIMPL; }
-    virtual KResult protocol_connect(OpenFileDescription&, ShouldBlock) { return KSuccess; }
-    virtual KResultOr<u16> protocol_allocate_local_port() { return ENOPROTOOPT; }
+    virtual ErrorOr<void> protocol_bind() { return {}; }
+    virtual ErrorOr<void> protocol_listen([[maybe_unused]] bool did_allocate_port) { return {}; }
+    virtual ErrorOr<size_t> protocol_receive(ReadonlyBytes /* raw_ipv4_packet */, UserOrKernelBuffer&, size_t, int) { return ENOTIMPL; }
+    virtual ErrorOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) { return ENOTIMPL; }
+    virtual ErrorOr<void> protocol_connect(OpenFileDescription&, ShouldBlock) { return {}; }
+    virtual ErrorOr<u16> protocol_allocate_local_port() { return ENOPROTOOPT; }
     virtual bool protocol_is_disconnected() const { return false; }
 
     virtual void shut_down_for_reading() override;
@@ -91,14 +91,14 @@ protected:
     void set_local_address(IPv4Address address) { m_local_address = address; }
     void set_peer_address(IPv4Address address) { m_peer_address = address; }
 
-    static KResultOr<NonnullOwnPtr<DoubleBuffer>> try_create_receive_buffer();
+    static ErrorOr<NonnullOwnPtr<DoubleBuffer>> try_create_receive_buffer();
     void drop_receive_buffer();
 
 private:
     virtual bool is_ipv4() const override { return true; }
 
-    KResultOr<size_t> receive_byte_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>);
-    KResultOr<size_t> receive_packet_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&);
+    ErrorOr<size_t> receive_byte_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>);
+    ErrorOr<size_t> receive_packet_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&);
 
     void set_can_read(bool);
 
diff --git a/Kernel/Net/LocalSocket.cpp b/Kernel/Net/LocalSocket.cpp
index 47e428c9536..b66b91fff3a 100644
--- a/Kernel/Net/LocalSocket.cpp
+++ b/Kernel/Net/LocalSocket.cpp
@@ -34,14 +34,14 @@ void LocalSocket::for_each(Function<void(const LocalSocket&)> callback)
     });
 }
 
-KResultOr<NonnullRefPtr<LocalSocket>> LocalSocket::try_create(int type)
+ErrorOr<NonnullRefPtr<LocalSocket>> LocalSocket::try_create(int type)
 {
     auto client_buffer = TRY(DoubleBuffer::try_create());
     auto server_buffer = TRY(DoubleBuffer::try_create());
     return adopt_nonnull_ref_or_enomem(new (nothrow) LocalSocket(type, move(client_buffer), move(server_buffer)));
 }
 
-KResultOr<SocketPair> LocalSocket::try_create_connected_pair(int type)
+ErrorOr<SocketPair> LocalSocket::try_create_connected_pair(int type)
 {
     auto socket = TRY(LocalSocket::try_create(type));
     auto description1 = TRY(OpenFileDescription::try_create(*socket));
@@ -106,7 +106,7 @@ void LocalSocket::get_peer_address(sockaddr* address, socklen_t* address_size)
     get_local_address(address, address_size);
 }
 
-KResult LocalSocket::bind(Userspace<const sockaddr*> user_address, socklen_t address_size)
+ErrorOr<void> LocalSocket::bind(Userspace<const sockaddr*> user_address, socklen_t address_size)
 {
     VERIFY(setup_state() == SetupState::Unstarted);
     if (address_size != sizeof(sockaddr_un))
@@ -125,9 +125,9 @@ KResult LocalSocket::bind(Userspace<const sockaddr*> user_address, socklen_t add
     UidAndGid owner { m_prebind_uid, m_prebind_gid };
     auto result = VirtualFileSystem::the().open(path->view(), O_CREAT | O_EXCL | O_NOFOLLOW_NOERROR, mode, Process::current().current_directory(), owner);
     if (result.is_error()) {
-        if (result.error() == EEXIST)
+        if (result.error().code() == EEXIST)
             return set_so_error(EADDRINUSE);
-        return result.error();
+        return result.release_error();
     }
 
     auto file = move(result.value());
@@ -141,10 +141,10 @@ KResult LocalSocket::bind(Userspace<const sockaddr*> user_address, socklen_t add
 
     m_path = move(path);
     m_bound = true;
-    return KSuccess;
+    return {};
 }
 
-KResult LocalSocket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock)
+ErrorOr<void> LocalSocket::connect(OpenFileDescription& description, Userspace<const sockaddr*> address, socklen_t address_size, ShouldBlock)
 {
     VERIFY(!m_bound);
     if (address_size != sizeof(sockaddr_un))
@@ -191,7 +191,7 @@ KResult LocalSocket::connect(OpenFileDescription& description, Userspace<const s
 
     if (is_connected()) {
         set_connect_side_role(Role::Connected);
-        return KSuccess;
+        return {};
     }
 
     auto unblock_flags = Thread::OpenFileDescriptionBlocker::BlockFlags::None;
@@ -207,10 +207,10 @@ KResult LocalSocket::connect(OpenFileDescription& description, Userspace<const s
         return set_so_error(ECONNREFUSED);
     }
     set_connect_side_role(Role::Connected);
-    return KSuccess;
+    return {};
 }
 
-KResult LocalSocket::listen(size_t backlog)
+ErrorOr<void> LocalSocket::listen(size_t backlog)
 {
     MutexLocker locker(mutex());
     if (type() != SOCK_STREAM)
@@ -222,10 +222,10 @@ KResult LocalSocket::listen(size_t backlog)
 
     dbgln_if(LOCAL_SOCKET_DEBUG, "LocalSocket({}) listening with backlog={}", this, backlog);
 
-    return KSuccess;
+    return {};
 }
 
-KResult LocalSocket::attach(OpenFileDescription& description)
+ErrorOr<void> LocalSocket::attach(OpenFileDescription& description)
 {
     VERIFY(!m_accept_side_fd_open);
     if (m_connect_side_role == Role::None) {
@@ -237,7 +237,7 @@ KResult LocalSocket::attach(OpenFileDescription& description)
     }
 
     evaluate_block_conditions();
-    return KSuccess;
+    return {};
 }
 
 void LocalSocket::detach(OpenFileDescription& description)
@@ -290,7 +290,7 @@ bool LocalSocket::can_write(const OpenFileDescription& description, size_t) cons
     return false;
 }
 
-KResultOr<size_t> LocalSocket::sendto(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size, int, Userspace<const sockaddr*>, socklen_t)
+ErrorOr<size_t> LocalSocket::sendto(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size, int, Userspace<const sockaddr*>, socklen_t)
 {
     if (!has_attached_peer(description))
         return set_so_error(EPIPE);
@@ -323,7 +323,7 @@ DoubleBuffer* LocalSocket::send_buffer_for(OpenFileDescription& description)
     return nullptr;
 }
 
-KResultOr<size_t> LocalSocket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_size, int, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&)
+ErrorOr<size_t> LocalSocket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_size, int, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&)
 {
     auto* socket_buffer = receive_buffer_for(description);
     if (!socket_buffer)
@@ -355,7 +355,7 @@ StringView LocalSocket::socket_path() const
     return m_path->view();
 }
 
-KResultOr<NonnullOwnPtr<KString>> LocalSocket::pseudo_path(const OpenFileDescription& description) const
+ErrorOr<NonnullOwnPtr<KString>> LocalSocket::pseudo_path(const OpenFileDescription& description) const
 {
     StringBuilder builder;
     builder.append("socket:");
@@ -381,7 +381,7 @@ KResultOr<NonnullOwnPtr<KString>> LocalSocket::pseudo_path(const OpenFileDescrip
     return KString::try_create(builder.to_string());
 }
 
-KResult LocalSocket::getsockopt(OpenFileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
+ErrorOr<void> LocalSocket::getsockopt(OpenFileDescription& description, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
 {
     if (level != SOL_SOCKET)
         return Socket::getsockopt(description, level, option, value, value_size);
@@ -402,12 +402,12 @@ KResult LocalSocket::getsockopt(OpenFileDescription& description, int level, int
             TRY(copy_to_user(static_ptr_cast<ucred*>(value), &m_origin));
             size = sizeof(ucred);
             TRY(copy_to_user(value_size, &size));
-            return KSuccess;
+            return {};
         case Role::Connected:
             TRY(copy_to_user(static_ptr_cast<ucred*>(value), &m_acceptor));
             size = sizeof(ucred);
             TRY(copy_to_user(value_size, &size));
-            return KSuccess;
+            return {};
         case Role::Connecting:
             return ENOTCONN;
         default:
@@ -420,7 +420,7 @@ KResult LocalSocket::getsockopt(OpenFileDescription& description, int level, int
     }
 }
 
-KResult LocalSocket::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
+ErrorOr<void> LocalSocket::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case FIONREAD: {
@@ -432,17 +432,17 @@ KResult LocalSocket::ioctl(OpenFileDescription& description, unsigned request, U
     return ENOTTY;
 }
 
-KResult LocalSocket::chmod(OpenFileDescription&, mode_t mode)
+ErrorOr<void> LocalSocket::chmod(OpenFileDescription&, mode_t mode)
 {
     auto inode = m_inode.strong_ref();
     if (inode)
         return inode->chmod(mode);
 
     m_prebind_mode = mode & 0777;
-    return KSuccess;
+    return {};
 }
 
-KResult LocalSocket::chown(OpenFileDescription&, UserID uid, GroupID gid)
+ErrorOr<void> LocalSocket::chown(OpenFileDescription&, UserID uid, GroupID gid)
 {
     auto inode = m_inode.strong_ref();
     if (inode)
@@ -454,7 +454,7 @@ KResult LocalSocket::chown(OpenFileDescription&, UserID uid, GroupID gid)
 
     m_prebind_uid = uid;
     m_prebind_gid = gid;
-    return KSuccess;
+    return {};
 }
 
 NonnullRefPtrVector<OpenFileDescription>& LocalSocket::recvfd_queue_for(const OpenFileDescription& description)
@@ -477,7 +477,7 @@ NonnullRefPtrVector<OpenFileDescription>& LocalSocket::sendfd_queue_for(const Op
     VERIFY_NOT_REACHED();
 }
 
-KResult LocalSocket::sendfd(OpenFileDescription const& socket_description, NonnullRefPtr<OpenFileDescription> passing_description)
+ErrorOr<void> LocalSocket::sendfd(OpenFileDescription const& socket_description, NonnullRefPtr<OpenFileDescription> passing_description)
 {
     MutexLocker locker(mutex());
     auto role = this->role(socket_description);
@@ -489,10 +489,10 @@ KResult LocalSocket::sendfd(OpenFileDescription const& socket_description, Nonnu
         return set_so_error(EBUSY);
     if (!queue.try_append(move(passing_description)))
         return set_so_error(ENOMEM);
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> LocalSocket::recvfd(const OpenFileDescription& socket_description)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> LocalSocket::recvfd(const OpenFileDescription& socket_description)
 {
     MutexLocker locker(mutex());
     auto role = this->role(socket_description);
@@ -506,10 +506,10 @@ KResultOr<NonnullRefPtr<OpenFileDescription>> LocalSocket::recvfd(const OpenFile
     return queue.take_first();
 }
 
-KResult LocalSocket::try_set_path(StringView path)
+ErrorOr<void> LocalSocket::try_set_path(StringView path)
 {
     m_path = TRY(KString::try_create(path));
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/Net/LocalSocket.h b/Kernel/Net/LocalSocket.h
index 97705f10186..881eb29cf7c 100644
--- a/Kernel/Net/LocalSocket.h
+++ b/Kernel/Net/LocalSocket.h
@@ -22,34 +22,34 @@ struct SocketPair {
 class LocalSocket final : public Socket {
 
 public:
-    static KResultOr<NonnullRefPtr<LocalSocket>> try_create(int type);
-    static KResultOr<SocketPair> try_create_connected_pair(int type);
+    static ErrorOr<NonnullRefPtr<LocalSocket>> try_create(int type);
+    static ErrorOr<SocketPair> try_create_connected_pair(int type);
     virtual ~LocalSocket() override;
 
-    KResult sendfd(OpenFileDescription const& socket_description, NonnullRefPtr<OpenFileDescription> passing_description);
-    KResultOr<NonnullRefPtr<OpenFileDescription>> recvfd(const OpenFileDescription& socket_description);
+    ErrorOr<void> sendfd(OpenFileDescription const& socket_description, NonnullRefPtr<OpenFileDescription> passing_description);
+    ErrorOr<NonnullRefPtr<OpenFileDescription>> recvfd(const OpenFileDescription& socket_description);
 
     static void for_each(Function<void(const LocalSocket&)>);
 
     StringView socket_path() const;
-    KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription& description) const override;
+    ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription& description) const override;
 
     // ^Socket
-    virtual KResult bind(Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResult connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
-    virtual KResult listen(size_t) override;
+    virtual ErrorOr<void> bind(Userspace<const sockaddr*>, socklen_t) override;
+    virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock = ShouldBlock::Yes) override;
+    virtual ErrorOr<void> listen(size_t) override;
     virtual void get_local_address(sockaddr*, socklen_t*) override;
     virtual void get_peer_address(sockaddr*, socklen_t*) override;
-    virtual KResult attach(OpenFileDescription&) override;
+    virtual ErrorOr<void> attach(OpenFileDescription&) override;
     virtual void detach(OpenFileDescription&) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
-    virtual KResultOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
-    virtual KResult getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
-    virtual KResult chown(OpenFileDescription&, UserID, GroupID) override;
-    virtual KResult chmod(OpenFileDescription&, mode_t) override;
+    virtual ErrorOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int, Userspace<const sockaddr*>, socklen_t) override;
+    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) override;
+    virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual ErrorOr<void> chown(OpenFileDescription&, UserID, GroupID) override;
+    virtual ErrorOr<void> chmod(OpenFileDescription&, mode_t) override;
 
 private:
     explicit LocalSocket(int type, NonnullOwnPtr<DoubleBuffer> client_buffer, NonnullOwnPtr<DoubleBuffer> server_buffer);
@@ -69,7 +69,7 @@ private:
             evaluate_block_conditions();
     }
 
-    KResult try_set_path(StringView);
+    ErrorOr<void> try_set_path(StringView);
 
     // The inode this socket is bound to.
     WeakPtr<Inode> m_inode;
diff --git a/Kernel/Net/NetworkingManagement.cpp b/Kernel/Net/NetworkingManagement.cpp
index 3464695d7f1..64ed1ef2a65 100644
--- a/Kernel/Net/NetworkingManagement.cpp
+++ b/Kernel/Net/NetworkingManagement.cpp
@@ -74,7 +74,7 @@ RefPtr<NetworkAdapter> NetworkingManagement::lookup_by_name(const StringView& na
     return found_adapter;
 }
 
-KResultOr<NonnullOwnPtr<KString>> NetworkingManagement::generate_interface_name_from_pci_address(PCI::DeviceIdentifier const& device_identifier)
+ErrorOr<NonnullOwnPtr<KString>> NetworkingManagement::generate_interface_name_from_pci_address(PCI::DeviceIdentifier const& device_identifier)
 {
     VERIFY(device_identifier.class_code().value() == 0x2);
     // Note: This stands for e - "Ethernet", p - "Port" as for PCI bus, "s" for slot as for PCI slot
diff --git a/Kernel/Net/NetworkingManagement.h b/Kernel/Net/NetworkingManagement.h
index 418b43c5268..cec11713cf1 100644
--- a/Kernel/Net/NetworkingManagement.h
+++ b/Kernel/Net/NetworkingManagement.h
@@ -27,7 +27,7 @@ public:
     static bool is_initialized();
     bool initialize();
 
-    static KResultOr<NonnullOwnPtr<KString>> generate_interface_name_from_pci_address(PCI::DeviceIdentifier const&);
+    static ErrorOr<NonnullOwnPtr<KString>> generate_interface_name_from_pci_address(PCI::DeviceIdentifier const&);
 
     NetworkingManagement();
 
diff --git a/Kernel/Net/Socket.cpp b/Kernel/Net/Socket.cpp
index 812448d784c..151eba6e909 100644
--- a/Kernel/Net/Socket.cpp
+++ b/Kernel/Net/Socket.cpp
@@ -17,7 +17,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<Socket>> Socket::create(int domain, int type, int protocol)
+ErrorOr<NonnullRefPtr<Socket>> Socket::create(int domain, int type, int protocol)
 {
     switch (domain) {
     case AF_LOCAL:
@@ -65,7 +65,7 @@ RefPtr<Socket> Socket::accept()
     return client;
 }
 
-KResult Socket::queue_connection_from(NonnullRefPtr<Socket> peer)
+ErrorOr<void> Socket::queue_connection_from(NonnullRefPtr<Socket> peer)
 {
     dbgln_if(SOCKET_DEBUG, "Socket({}) queueing connection", this);
     MutexLocker locker(mutex());
@@ -74,10 +74,10 @@ KResult Socket::queue_connection_from(NonnullRefPtr<Socket> peer)
     if (!m_pending.try_append(peer))
         return set_so_error(ENOMEM);
     evaluate_block_conditions();
-    return KSuccess;
+    return {};
 }
 
-KResult Socket::setsockopt(int level, int option, Userspace<const void*> user_value, socklen_t user_value_size)
+ErrorOr<void> Socket::setsockopt(int level, int option, Userspace<const void*> user_value, socklen_t user_value_size)
 {
     if (level != SOL_SOCKET)
         return ENOPROTOOPT;
@@ -87,12 +87,12 @@ KResult Socket::setsockopt(int level, int option, Userspace<const void*> user_va
         if (user_value_size != sizeof(timeval))
             return EINVAL;
         m_send_timeout = TRY(copy_time_from_user(static_ptr_cast<timeval const*>(user_value)));
-        return KSuccess;
+        return {};
     case SO_RCVTIMEO:
         if (user_value_size != sizeof(timeval))
             return EINVAL;
         m_receive_timeout = TRY(copy_time_from_user(static_ptr_cast<timeval const*>(user_value)));
-        return KSuccess;
+        return {};
     case SO_BINDTODEVICE: {
         if (user_value_size != IFNAMSIZ)
             return EINVAL;
@@ -102,11 +102,11 @@ KResult Socket::setsockopt(int level, int option, Userspace<const void*> user_va
         if (!device)
             return ENODEV;
         m_bound_interface = move(device);
-        return KSuccess;
+        return {};
     }
     case SO_KEEPALIVE:
         // FIXME: Obviously, this is not a real keepalive.
-        return KSuccess;
+        return {};
     case SO_TIMESTAMP:
         if (user_value_size != sizeof(int))
             return EINVAL;
@@ -120,14 +120,14 @@ KResult Socket::setsockopt(int level, int option, Userspace<const void*> user_va
             m_timestamp = 0;
             return ENOTSUP;
         }
-        return KSuccess;
+        return {};
     default:
         dbgln("setsockopt({}) at SOL_SOCKET not implemented.", option);
         return ENOPROTOOPT;
     }
 }
 
-KResult Socket::getsockopt(OpenFileDescription&, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
+ErrorOr<void> Socket::getsockopt(OpenFileDescription&, int level, int option, Userspace<void*> value, Userspace<socklen_t*> value_size)
 {
     socklen_t size;
     TRY(copy_from_user(&size, value_size.unsafe_userspace_ptr()));
@@ -160,11 +160,16 @@ KResult Socket::getsockopt(OpenFileDescription&, int level, int option, Userspac
     case SO_ERROR: {
         if (size < sizeof(int))
             return EINVAL;
-        int errno = so_error().error();
+        int errno;
+        if (so_error().is_error())
+            errno = so_error().error().code();
+        else
+            errno = 0;
         TRY(copy_to_user(static_ptr_cast<int*>(value), &errno));
         size = sizeof(int);
         TRY(copy_to_user(value_size, &size));
-        return set_so_error(KSuccess);
+        clear_so_error();
+        return {};
     }
     case SO_BINDTODEVICE:
         if (size < IFNAMSIZ)
@@ -200,7 +205,7 @@ KResult Socket::getsockopt(OpenFileDescription&, int level, int option, Userspac
     }
 }
 
-KResultOr<size_t> Socket::read(OpenFileDescription& description, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> Socket::read(OpenFileDescription& description, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (is_shut_down_for_reading())
         return 0;
@@ -208,14 +213,14 @@ KResultOr<size_t> Socket::read(OpenFileDescription& description, u64, UserOrKern
     return recvfrom(description, buffer, size, 0, {}, 0, t);
 }
 
-KResultOr<size_t> Socket::write(OpenFileDescription& description, u64, const UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> Socket::write(OpenFileDescription& description, u64, const UserOrKernelBuffer& data, size_t size)
 {
     if (is_shut_down_for_writing())
         return set_so_error(EPIPE);
     return sendto(description, data, size, 0, {}, 0);
 }
 
-KResult Socket::shutdown(int how)
+ErrorOr<void> Socket::shutdown(int how)
 {
     MutexLocker locker(mutex());
     if (type() == SOCK_STREAM && !is_connected())
@@ -228,14 +233,14 @@ KResult Socket::shutdown(int how)
         shut_down_for_reading();
     m_shut_down_for_reading |= (how & SHUT_RD) != 0;
     m_shut_down_for_writing |= (how & SHUT_WR) != 0;
-    return KSuccess;
+    return {};
 }
 
-KResult Socket::stat(::stat& st) const
+ErrorOr<void> Socket::stat(::stat& st) const
 {
     memset(&st, 0, sizeof(st));
     st.st_mode = S_IFSOCK;
-    return KSuccess;
+    return {};
 }
 
 void Socket::set_connected(bool connected)
diff --git a/Kernel/Net/Socket.h b/Kernel/Net/Socket.h
index d623bdb5fd6..b7d069c6bf8 100644
--- a/Kernel/Net/Socket.h
+++ b/Kernel/Net/Socket.h
@@ -6,11 +6,11 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/NonnullRefPtrVector.h>
 #include <AK/RefCounted.h>
 #include <AK/RefPtr.h>
 #include <AK/Time.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/FileSystem/File.h>
 #include <Kernel/Locking/Mutex.h>
 #include <Kernel/Net/NetworkAdapter.h>
@@ -27,7 +27,7 @@ class OpenFileDescription;
 
 class Socket : public File {
 public:
-    static KResultOr<NonnullRefPtr<Socket>> create(int domain, int type, int protocol);
+    static ErrorOr<NonnullRefPtr<Socket>> create(int domain, int type, int protocol);
     virtual ~Socket() override;
 
     int domain() const { return m_domain; }
@@ -76,20 +76,20 @@ public:
     bool can_accept() const { return !m_pending.is_empty(); }
     RefPtr<Socket> accept();
 
-    KResult shutdown(int how);
+    ErrorOr<void> shutdown(int how);
 
-    virtual KResult bind(Userspace<const sockaddr*>, socklen_t) = 0;
-    virtual KResult connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock) = 0;
-    virtual KResult listen(size_t) = 0;
+    virtual ErrorOr<void> bind(Userspace<const sockaddr*>, socklen_t) = 0;
+    virtual ErrorOr<void> connect(OpenFileDescription&, Userspace<const sockaddr*>, socklen_t, ShouldBlock) = 0;
+    virtual ErrorOr<void> listen(size_t) = 0;
     virtual void get_local_address(sockaddr*, socklen_t*) = 0;
     virtual void get_peer_address(sockaddr*, socklen_t*) = 0;
     virtual bool is_local() const { return false; }
     virtual bool is_ipv4() const { return false; }
-    virtual KResultOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int flags, Userspace<const sockaddr*>, socklen_t) = 0;
-    virtual KResultOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) = 0;
+    virtual ErrorOr<size_t> sendto(OpenFileDescription&, const UserOrKernelBuffer&, size_t, int flags, Userspace<const sockaddr*>, socklen_t) = 0;
+    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&) = 0;
 
-    virtual KResult setsockopt(int level, int option, Userspace<const void*>, socklen_t);
-    virtual KResult getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>);
+    virtual ErrorOr<void> setsockopt(int level, int option, Userspace<const void*>, socklen_t);
+    virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>);
 
     ProcessID origin_pid() const { return m_origin.pid; }
     UserID origin_uid() const { return m_origin.uid; }
@@ -102,10 +102,10 @@ public:
     Mutex& mutex() { return m_mutex; }
 
     // ^File
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override final;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override final;
-    virtual KResult stat(::stat&) const override;
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override = 0;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override final;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override final;
+    virtual ErrorOr<void> stat(::stat&) const override;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override = 0;
 
     bool has_receive_timeout() const { return m_receive_timeout != Time::zero(); }
     const Time& receive_timeout() const { return m_receive_timeout; }
@@ -118,7 +118,7 @@ public:
 protected:
     Socket(int domain, int type, int protocol);
 
-    KResult queue_connection_from(NonnullRefPtr<Socket>);
+    ErrorOr<void> queue_connection_from(NonnullRefPtr<Socket>);
 
     size_t backlog() const { return m_backlog; }
     void set_backlog(size_t backlog) { m_backlog = backlog; }
@@ -130,13 +130,25 @@ protected:
 
     Role m_role { Role::None };
 
-    KResult so_error() const { return m_so_error; }
-    KResult set_so_error(KResult error)
+    ErrorOr<void> so_error() const { return m_so_error; }
+
+    Error set_so_error(ErrnoCode error_code)
+    {
+        auto error = Error::from_errno(error_code);
+        m_so_error = error;
+        return error;
+    }
+    Error set_so_error(Error error)
     {
         m_so_error = error;
         return error;
     }
 
+    void clear_so_error()
+    {
+        m_so_error = {};
+    }
+
     void set_origin(Process const&);
     void set_acceptor(Process const&);
 
@@ -166,7 +178,7 @@ private:
     Time m_send_timeout {};
     int m_timestamp { 0 };
 
-    KResult m_so_error { KSuccess };
+    ErrorOr<void> m_so_error;
 
     NonnullRefPtrVector<Socket> m_pending;
 };
diff --git a/Kernel/Net/TCPSocket.cpp b/Kernel/Net/TCPSocket.cpp
index 24f078cdc3f..b3091b85b5f 100644
--- a/Kernel/Net/TCPSocket.cpp
+++ b/Kernel/Net/TCPSocket.cpp
@@ -40,7 +40,7 @@ void TCPSocket::set_state(State new_state)
 
     if (new_state == State::Established && m_direction == Direction::Outgoing) {
         set_role(Role::Connected);
-        [[maybe_unused]] auto rc = set_so_error(KSuccess);
+        clear_so_error();
     }
 
     if (new_state == State::TimeWait) {
@@ -97,10 +97,10 @@ RefPtr<TCPSocket> TCPSocket::from_tuple(const IPv4SocketTuple& tuple)
         return {};
     });
 }
-KResultOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create_client(const IPv4Address& new_local_address, u16 new_local_port, const IPv4Address& new_peer_address, u16 new_peer_port)
+ErrorOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create_client(const IPv4Address& new_local_address, u16 new_local_port, const IPv4Address& new_peer_address, u16 new_peer_port)
 {
     auto tuple = IPv4SocketTuple(new_local_address, new_local_port, new_peer_address, new_peer_port);
-    return sockets_by_tuple().with_exclusive([&](auto& table) -> KResultOr<NonnullRefPtr<TCPSocket>> {
+    return sockets_by_tuple().with_exclusive([&](auto& table) -> ErrorOr<NonnullRefPtr<TCPSocket>> {
         if (table.contains(tuple))
             return EEXIST;
 
@@ -154,14 +154,14 @@ TCPSocket::~TCPSocket()
     dbgln_if(TCP_SOCKET_DEBUG, "~TCPSocket in state {}", to_string(state()));
 }
 
-KResultOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer)
+ErrorOr<NonnullRefPtr<TCPSocket>> TCPSocket::try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer)
 {
     // Note: Scratch buffer is only used for SOCK_STREAM sockets.
     auto scratch_buffer = TRY(KBuffer::try_create_with_size(65536));
     return adopt_nonnull_ref_or_enomem(new (nothrow) TCPSocket(protocol, move(receive_buffer), move(scratch_buffer)));
 }
 
-KResultOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
+ErrorOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
 {
     auto& ipv4_packet = *reinterpret_cast<const IPv4Packet*>(raw_ipv4_packet.data());
     auto& tcp_packet = *static_cast<const TCPPacket*>(ipv4_packet.payload());
@@ -172,7 +172,7 @@ KResultOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, Use
     return payload_size;
 }
 
-KResultOr<size_t> TCPSocket::protocol_send(const UserOrKernelBuffer& data, size_t data_length)
+ErrorOr<size_t> TCPSocket::protocol_send(const UserOrKernelBuffer& data, size_t data_length)
 {
     RoutingDecision routing_decision = route_to(peer_address(), local_address(), bound_interface());
     if (routing_decision.is_zero())
@@ -183,14 +183,14 @@ KResultOr<size_t> TCPSocket::protocol_send(const UserOrKernelBuffer& data, size_
     return data_length;
 }
 
-KResult TCPSocket::send_ack(bool allow_duplicate)
+ErrorOr<void> TCPSocket::send_ack(bool allow_duplicate)
 {
     if (!allow_duplicate && m_last_ack_number_sent == m_ack_number)
-        return KSuccess;
+        return {};
     return send_tcp_packet(TCPFlags::ACK);
 }
 
-KResult TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload, size_t payload_size, RoutingDecision* user_routing_decision)
+ErrorOr<void> TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload, size_t payload_size, RoutingDecision* user_routing_decision)
 {
     RoutingDecision routing_decision = user_routing_decision ? *user_routing_decision : route_to(peer_address(), local_address(), bound_interface());
     if (routing_decision.is_zero())
@@ -227,7 +227,7 @@ KResult TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload,
     if (payload) {
         if (auto result = payload->read(tcp_packet.payload(), payload_size); result.is_error()) {
             routing_decision.adapter->release_packet_buffer(*packet);
-            return set_so_error(result);
+            return set_so_error(result.release_error());
         }
     }
 
@@ -260,7 +260,7 @@ KResult TCPSocket::send_tcp_packet(u16 flags, const UserOrKernelBuffer* payload,
         routing_decision.adapter->release_packet_buffer(*packet);
     }
 
-    return KSuccess;
+    return {};
 }
 
 void TCPSocket::receive_tcp_packet(const TCPPacket& packet, u16 size)
@@ -362,7 +362,7 @@ NetworkOrdered<u16> TCPSocket::compute_tcp_checksum(const IPv4Address& source, c
     return ~(checksum & 0xffff);
 }
 
-KResult TCPSocket::protocol_bind()
+ErrorOr<void> TCPSocket::protocol_bind()
 {
     if (has_specific_local_address() && !m_adapter) {
         m_adapter = NetworkingManagement::the().from_ipv4_address(local_address());
@@ -370,10 +370,10 @@ KResult TCPSocket::protocol_bind()
             return set_so_error(EADDRNOTAVAIL);
     }
 
-    return KSuccess;
+    return {};
 }
 
-KResult TCPSocket::protocol_listen(bool did_allocate_port)
+ErrorOr<void> TCPSocket::protocol_listen(bool did_allocate_port)
 {
     if (!did_allocate_port) {
         bool ok = sockets_by_tuple().with_exclusive([&](auto& table) -> bool {
@@ -389,10 +389,10 @@ KResult TCPSocket::protocol_listen(bool did_allocate_port)
     set_direction(Direction::Passive);
     set_state(State::Listen);
     set_setup_state(SetupState::Completed);
-    return KSuccess;
+    return {};
 }
 
-KResult TCPSocket::protocol_connect(OpenFileDescription& description, ShouldBlock should_block)
+ErrorOr<void> TCPSocket::protocol_connect(OpenFileDescription& description, ShouldBlock should_block)
 {
     MutexLocker locker(mutex());
 
@@ -403,7 +403,7 @@ KResult TCPSocket::protocol_connect(OpenFileDescription& description, ShouldBloc
         set_local_address(routing_decision.adapter->ipv4_address());
 
     if (auto result = allocate_local_port_if_needed(); result.error_or_port.is_error())
-        return result.error_or_port.error();
+        return result.error_or_port.release_error();
 
     m_sequence_number = get_good_random<u32>();
     m_ack_number = 0;
@@ -430,20 +430,20 @@ KResult TCPSocket::protocol_connect(OpenFileDescription& description, ShouldBloc
             else
                 return set_so_error(ECONNREFUSED);
         }
-        return KSuccess;
+        return {};
     }
 
     return set_so_error(EINPROGRESS);
 }
 
-KResultOr<u16> TCPSocket::protocol_allocate_local_port()
+ErrorOr<u16> TCPSocket::protocol_allocate_local_port()
 {
     constexpr u16 first_ephemeral_port = 32768;
     constexpr u16 last_ephemeral_port = 60999;
     constexpr u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
     u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
 
-    return sockets_by_tuple().with_exclusive([&](auto& table) -> KResultOr<u16> {
+    return sockets_by_tuple().with_exclusive([&](auto& table) -> ErrorOr<u16> {
         for (u16 port = first_scan_port;;) {
             IPv4SocketTuple proposed_tuple(local_address(), port, peer_address(), peer_port());
 
@@ -490,7 +490,7 @@ void TCPSocket::shut_down_for_writing()
     }
 }
 
-KResult TCPSocket::close()
+ErrorOr<void> TCPSocket::close()
 {
     MutexLocker locker(mutex());
     auto result = IPv4Socket::close();
diff --git a/Kernel/Net/TCPSocket.h b/Kernel/Net/TCPSocket.h
index 2dcc8774645..b8c60c3fd69 100644
--- a/Kernel/Net/TCPSocket.h
+++ b/Kernel/Net/TCPSocket.h
@@ -6,11 +6,11 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/Function.h>
 #include <AK/HashMap.h>
 #include <AK/SinglyLinkedList.h>
 #include <AK/WeakPtr.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Locking/MutexProtected.h>
 #include <Kernel/Net/IPv4Socket.h>
 
@@ -19,7 +19,7 @@ namespace Kernel {
 class TCPSocket final : public IPv4Socket {
 public:
     static void for_each(Function<void(const TCPSocket&)>);
-    static KResultOr<NonnullRefPtr<TCPSocket>> try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer);
+    static ErrorOr<NonnullRefPtr<TCPSocket>> try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer);
     virtual ~TCPSocket() override;
 
     enum class Direction {
@@ -136,8 +136,8 @@ public:
     void set_duplicate_acks(u32 acks) { m_duplicate_acks = acks; }
     u32 duplicate_acks() const { return m_duplicate_acks; }
 
-    KResult send_ack(bool allow_duplicate = false);
-    KResult send_tcp_packet(u16 flags, const UserOrKernelBuffer* = nullptr, size_t = 0, RoutingDecision* = nullptr);
+    ErrorOr<void> send_ack(bool allow_duplicate = false);
+    ErrorOr<void> send_tcp_packet(u16 flags, const UserOrKernelBuffer* = nullptr, size_t = 0, RoutingDecision* = nullptr);
     void receive_tcp_packet(const TCPPacket&, u16 size);
 
     bool should_delay_next_ack() const;
@@ -147,7 +147,7 @@ public:
 
     static MutexProtected<HashMap<IPv4SocketTuple, RefPtr<TCPSocket>>>& closing_sockets();
 
-    KResultOr<NonnullRefPtr<TCPSocket>> try_create_client(IPv4Address const& local_address, u16 local_port, IPv4Address const& peer_address, u16 peer_port);
+    ErrorOr<NonnullRefPtr<TCPSocket>> try_create_client(IPv4Address const& local_address, u16 local_port, IPv4Address const& peer_address, u16 peer_port);
     void set_originator(TCPSocket& originator) { m_originator = originator; }
     bool has_originator() { return !!m_originator; }
     void release_to_originator();
@@ -155,7 +155,7 @@ public:
 
     void retransmit_packets();
 
-    virtual KResult close() override;
+    virtual ErrorOr<void> close() override;
 
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
 
@@ -170,13 +170,13 @@ private:
 
     virtual void shut_down_for_writing() override;
 
-    virtual KResultOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
-    virtual KResultOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
-    virtual KResult protocol_connect(OpenFileDescription&, ShouldBlock) override;
-    virtual KResultOr<u16> protocol_allocate_local_port() override;
+    virtual ErrorOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
+    virtual ErrorOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<void> protocol_connect(OpenFileDescription&, ShouldBlock) override;
+    virtual ErrorOr<u16> protocol_allocate_local_port() override;
     virtual bool protocol_is_disconnected() const override;
-    virtual KResult protocol_bind() override;
-    virtual KResult protocol_listen(bool did_allocate_port) override;
+    virtual ErrorOr<void> protocol_bind() override;
+    virtual ErrorOr<void> protocol_listen(bool did_allocate_port) override;
 
     void enqueue_for_retransmit();
     void dequeue_for_retransmit();
diff --git a/Kernel/Net/UDPSocket.cpp b/Kernel/Net/UDPSocket.cpp
index 51847893c72..0a6b4eb7f83 100644
--- a/Kernel/Net/UDPSocket.cpp
+++ b/Kernel/Net/UDPSocket.cpp
@@ -54,12 +54,12 @@ UDPSocket::~UDPSocket()
     });
 }
 
-KResultOr<NonnullRefPtr<UDPSocket>> UDPSocket::try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer)
+ErrorOr<NonnullRefPtr<UDPSocket>> UDPSocket::try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer)
 {
     return adopt_nonnull_ref_or_enomem(new (nothrow) UDPSocket(protocol, move(receive_buffer)));
 }
 
-KResultOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
+ErrorOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
 {
     auto& ipv4_packet = *(const IPv4Packet*)(raw_ipv4_packet.data());
     auto& udp_packet = *static_cast<const UDPPacket*>(ipv4_packet.payload());
@@ -69,7 +69,7 @@ KResultOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, Use
     return read_size;
 }
 
-KResultOr<size_t> UDPSocket::protocol_send(const UserOrKernelBuffer& data, size_t data_length)
+ErrorOr<size_t> UDPSocket::protocol_send(const UserOrKernelBuffer& data, size_t data_length)
 {
     auto routing_decision = route_to(peer_address(), local_address(), bound_interface());
     if (routing_decision.is_zero())
@@ -92,21 +92,21 @@ KResultOr<size_t> UDPSocket::protocol_send(const UserOrKernelBuffer& data, size_
     return data_length;
 }
 
-KResult UDPSocket::protocol_connect(OpenFileDescription&, ShouldBlock)
+ErrorOr<void> UDPSocket::protocol_connect(OpenFileDescription&, ShouldBlock)
 {
     set_role(Role::Connected);
     set_connected(true);
-    return KSuccess;
+    return {};
 }
 
-KResultOr<u16> UDPSocket::protocol_allocate_local_port()
+ErrorOr<u16> UDPSocket::protocol_allocate_local_port()
 {
     constexpr u16 first_ephemeral_port = 32768;
     constexpr u16 last_ephemeral_port = 60999;
     constexpr u16 ephemeral_port_range_size = last_ephemeral_port - first_ephemeral_port;
     u16 first_scan_port = first_ephemeral_port + get_good_random<u16>() % ephemeral_port_range_size;
 
-    return sockets_by_port().with_exclusive([&](auto& table) -> KResultOr<u16> {
+    return sockets_by_port().with_exclusive([&](auto& table) -> ErrorOr<u16> {
         for (u16 port = first_scan_port;;) {
             auto it = table.find(port);
             if (it == table.end()) {
@@ -124,13 +124,13 @@ KResultOr<u16> UDPSocket::protocol_allocate_local_port()
     });
 }
 
-KResult UDPSocket::protocol_bind()
+ErrorOr<void> UDPSocket::protocol_bind()
 {
-    return sockets_by_port().with_exclusive([&](auto& table) -> KResult {
+    return sockets_by_port().with_exclusive([&](auto& table) -> ErrorOr<void> {
         if (table.contains(local_port()))
             return set_so_error(EADDRINUSE);
         table.set(local_port(), this);
-        return KSuccess;
+        return {};
     });
 }
 
diff --git a/Kernel/Net/UDPSocket.h b/Kernel/Net/UDPSocket.h
index c387ac536b0..74845b7a27e 100644
--- a/Kernel/Net/UDPSocket.h
+++ b/Kernel/Net/UDPSocket.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <Kernel/API/KResult.h>
+#include <AK/Error.h>
 #include <Kernel/Locking/MutexProtected.h>
 #include <Kernel/Net/IPv4Socket.h>
 
@@ -14,7 +14,7 @@ namespace Kernel {
 
 class UDPSocket final : public IPv4Socket {
 public:
-    static KResultOr<NonnullRefPtr<UDPSocket>> try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer);
+    static ErrorOr<NonnullRefPtr<UDPSocket>> try_create(int protocol, NonnullOwnPtr<DoubleBuffer> receive_buffer);
     virtual ~UDPSocket() override;
 
     static SocketHandle<UDPSocket> from_port(u16);
@@ -25,11 +25,11 @@ private:
     virtual StringView class_name() const override { return "UDPSocket"sv; }
     static MutexProtected<HashMap<u16, UDPSocket*>>& sockets_by_port();
 
-    virtual KResultOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
-    virtual KResultOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
-    virtual KResult protocol_connect(OpenFileDescription&, ShouldBlock) override;
-    virtual KResultOr<u16> protocol_allocate_local_port() override;
-    virtual KResult protocol_bind() override;
+    virtual ErrorOr<size_t> protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, int flags) override;
+    virtual ErrorOr<size_t> protocol_send(const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<void> protocol_connect(OpenFileDescription&, ShouldBlock) override;
+    virtual ErrorOr<u16> protocol_allocate_local_port() override;
+    virtual ErrorOr<void> protocol_bind() override;
 };
 
 }
diff --git a/Kernel/PerformanceEventBuffer.cpp b/Kernel/PerformanceEventBuffer.cpp
index 5aeca08000e..fc8e10f3da6 100644
--- a/Kernel/PerformanceEventBuffer.cpp
+++ b/Kernel/PerformanceEventBuffer.cpp
@@ -21,7 +21,7 @@ PerformanceEventBuffer::PerformanceEventBuffer(NonnullOwnPtr<KBuffer> buffer)
 {
 }
 
-NEVER_INLINE KResult PerformanceEventBuffer::append(int type, FlatPtr arg1, FlatPtr arg2, const StringView& arg3, Thread* current_thread)
+NEVER_INLINE ErrorOr<void> PerformanceEventBuffer::append(int type, FlatPtr arg1, FlatPtr arg2, const StringView& arg3, Thread* current_thread)
 {
     FlatPtr ebp;
     asm volatile("movl %%ebp, %%eax"
@@ -55,13 +55,13 @@ static Vector<FlatPtr, PerformanceEvent::max_stack_frame_count> raw_backtrace(Fl
     return backtrace;
 }
 
-KResult PerformanceEventBuffer::append_with_ip_and_bp(ProcessID pid, ThreadID tid, const RegisterState& regs,
+ErrorOr<void> PerformanceEventBuffer::append_with_ip_and_bp(ProcessID pid, ThreadID tid, const RegisterState& regs,
     int type, u32 lost_samples, FlatPtr arg1, FlatPtr arg2, const StringView& arg3)
 {
     return append_with_ip_and_bp(pid, tid, regs.ip(), regs.bp(), type, lost_samples, arg1, arg2, arg3);
 }
 
-KResult PerformanceEventBuffer::append_with_ip_and_bp(ProcessID pid, ThreadID tid,
+ErrorOr<void> PerformanceEventBuffer::append_with_ip_and_bp(ProcessID pid, ThreadID tid,
     FlatPtr ip, FlatPtr bp, int type, u32 lost_samples, FlatPtr arg1, FlatPtr arg2, const StringView& arg3)
 {
     if (count() >= capacity())
@@ -160,7 +160,7 @@ KResult PerformanceEventBuffer::append_with_ip_and_bp(ProcessID pid, ThreadID ti
     event.tid = tid.value();
     event.timestamp = TimeManagement::the().uptime_ms();
     at(m_count++) = event;
-    return KSuccess;
+    return {};
 }
 
 PerformanceEvent& PerformanceEventBuffer::at(size_t index)
@@ -171,7 +171,7 @@ PerformanceEvent& PerformanceEventBuffer::at(size_t index)
 }
 
 template<typename Serializer>
-KResult PerformanceEventBuffer::to_json_impl(Serializer& object) const
+ErrorOr<void> PerformanceEventBuffer::to_json_impl(Serializer& object) const
 {
     {
         auto strings = object.add_array("strings");
@@ -270,10 +270,10 @@ KResult PerformanceEventBuffer::to_json_impl(Serializer& object) const
     }
     array.finish();
     object.finish();
-    return KSuccess;
+    return {};
 }
 
-KResult PerformanceEventBuffer::to_json(KBufferBuilder& builder) const
+ErrorOr<void> PerformanceEventBuffer::to_json(KBufferBuilder& builder) const
 {
     JsonObjectSerializer object(builder);
     return to_json_impl(object);
@@ -312,7 +312,7 @@ void PerformanceEventBuffer::add_process(const Process& process, ProcessEventTyp
     }
 }
 
-KResultOr<FlatPtr> PerformanceEventBuffer::register_string(NonnullOwnPtr<KString> string)
+ErrorOr<FlatPtr> PerformanceEventBuffer::register_string(NonnullOwnPtr<KString> string)
 {
     FlatPtr string_id = m_strings.size();
 
diff --git a/Kernel/PerformanceEventBuffer.h b/Kernel/PerformanceEventBuffer.h
index 6247cb173d7..c8b84301390 100644
--- a/Kernel/PerformanceEventBuffer.h
+++ b/Kernel/PerformanceEventBuffer.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <Kernel/API/KResult.h>
+#include <AK/Error.h>
 #include <Kernel/KBuffer.h>
 
 namespace Kernel {
@@ -101,10 +101,10 @@ class PerformanceEventBuffer {
 public:
     static OwnPtr<PerformanceEventBuffer> try_create_with_size(size_t buffer_size);
 
-    KResult append(int type, FlatPtr arg1, FlatPtr arg2, const StringView& arg3, Thread* current_thread = Thread::current());
-    KResult append_with_ip_and_bp(ProcessID pid, ThreadID tid, FlatPtr eip, FlatPtr ebp,
+    ErrorOr<void> append(int type, FlatPtr arg1, FlatPtr arg2, const StringView& arg3, Thread* current_thread = Thread::current());
+    ErrorOr<void> append_with_ip_and_bp(ProcessID pid, ThreadID tid, FlatPtr eip, FlatPtr ebp,
         int type, u32 lost_samples, FlatPtr arg1, FlatPtr arg2, const StringView& arg3);
-    KResult append_with_ip_and_bp(ProcessID pid, ThreadID tid, const RegisterState& regs,
+    ErrorOr<void> append_with_ip_and_bp(ProcessID pid, ThreadID tid, const RegisterState& regs,
         int type, u32 lost_samples, FlatPtr arg1, FlatPtr arg2, const StringView& arg3);
 
     void clear()
@@ -119,17 +119,17 @@ public:
         return const_cast<PerformanceEventBuffer&>(*this).at(index);
     }
 
-    KResult to_json(KBufferBuilder&) const;
+    ErrorOr<void> to_json(KBufferBuilder&) const;
 
     void add_process(const Process&, ProcessEventType event_type);
 
-    KResultOr<FlatPtr> register_string(NonnullOwnPtr<KString>);
+    ErrorOr<FlatPtr> register_string(NonnullOwnPtr<KString>);
 
 private:
     explicit PerformanceEventBuffer(NonnullOwnPtr<KBuffer>);
 
     template<typename Serializer>
-    KResult to_json_impl(Serializer&) const;
+    ErrorOr<void> to_json_impl(Serializer&) const;
 
     PerformanceEvent& at(size_t index);
 
diff --git a/Kernel/Process.cpp b/Kernel/Process.cpp
index 261564954a8..88f52c60d2d 100644
--- a/Kernel/Process.cpp
+++ b/Kernel/Process.cpp
@@ -29,7 +29,6 @@
 #include <Kernel/PerformanceEventBuffer.h>
 #include <Kernel/PerformanceManager.h>
 #include <Kernel/Process.h>
-#include <Kernel/ProcessExposed.h>
 #include <Kernel/Sections.h>
 #include <Kernel/StdLib.h>
 #include <Kernel/TTY/TTY.h>
@@ -140,7 +139,7 @@ void Process::register_new(Process& process)
     });
 }
 
-KResultOr<NonnullRefPtr<Process>> Process::try_create_user_process(RefPtr<Thread>& first_thread, StringView path, UserID uid, GroupID gid, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, TTY* tty)
+ErrorOr<NonnullRefPtr<Process>> Process::try_create_user_process(RefPtr<Thread>& first_thread, StringView path, UserID uid, GroupID gid, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, TTY* tty)
 {
     auto parts = path.split_view('/');
     if (arguments.is_empty()) {
@@ -168,9 +167,9 @@ KResultOr<NonnullRefPtr<Process>> Process::try_create_user_process(RefPtr<Thread
     setup_description(2);
 
     if (auto result = process->exec(move(path_string), move(arguments), move(environment)); result.is_error()) {
-        dbgln("Failed to exec {}: {}", path, result);
+        dbgln("Failed to exec {}: {}", path, result.error());
         first_thread = nullptr;
-        return result;
+        return result.release_error();
     }
 
     register_new(*process);
@@ -218,7 +217,7 @@ void Process::unprotect_data()
     });
 }
 
-KResultOr<NonnullRefPtr<Process>> Process::try_create(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, UserID uid, GroupID gid, ProcessID ppid, bool is_kernel_process, RefPtr<Custody> cwd, RefPtr<Custody> executable, TTY* tty, Process* fork_parent)
+ErrorOr<NonnullRefPtr<Process>> Process::try_create(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, UserID uid, GroupID gid, ProcessID ppid, bool is_kernel_process, RefPtr<Custody> cwd, RefPtr<Custody> executable, TTY* tty, Process* fork_parent)
 {
     auto space = TRY(Memory::AddressSpace::try_create(fork_parent ? &fork_parent->address_space() : nullptr));
     auto process = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Process(move(name), uid, gid, ppid, is_kernel_process, move(cwd), move(executable), tty)));
@@ -249,7 +248,7 @@ Process::Process(NonnullOwnPtr<KString> name, UserID uid, GroupID gid, ProcessID
     dbgln_if(PROCESS_DEBUG, "Created new process {}({})", m_name, this->pid().value());
 }
 
-KResult Process::attach_resources(NonnullOwnPtr<Memory::AddressSpace>&& preallocated_space, RefPtr<Thread>& first_thread, Process* fork_parent)
+ErrorOr<void> Process::attach_resources(NonnullOwnPtr<Memory::AddressSpace>&& preallocated_space, RefPtr<Thread>& first_thread, Process* fork_parent)
 {
     m_space = move(preallocated_space);
 
@@ -270,7 +269,7 @@ KResult Process::attach_resources(NonnullOwnPtr<Memory::AddressSpace>&& prealloc
     }
 
     m_procfs_traits = TRY(ProcessProcFSTraits::try_create({}, *this));
-    return KSuccess;
+    return {};
 }
 
 Process::~Process()
@@ -450,7 +449,7 @@ Process::OpenFileDescriptionAndFlags& Process::OpenFileDescriptions::at(size_t i
     return m_fds_metadatas[i];
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> Process::OpenFileDescriptions::open_file_description(int fd) const
+ErrorOr<NonnullRefPtr<OpenFileDescription>> Process::OpenFileDescriptions::open_file_description(int fd) const
 {
     SpinlockLocker lock(m_fds_lock);
     if (fd < 0)
@@ -489,7 +488,7 @@ size_t Process::OpenFileDescriptions::open_count() const
     return count;
 }
 
-KResultOr<Process::ScopedDescriptionAllocation> Process::OpenFileDescriptions::allocate(int first_candidate_fd)
+ErrorOr<Process::ScopedDescriptionAllocation> Process::OpenFileDescriptions::allocate(int first_candidate_fd)
 {
     SpinlockLocker lock(m_fds_lock);
     for (size_t i = first_candidate_fd; i < max_open(); ++i) {
@@ -530,7 +529,7 @@ Custody& Process::current_directory()
     return *m_cwd;
 }
 
-KResultOr<NonnullOwnPtr<KString>> Process::get_syscall_path_argument(Userspace<char const*> user_path, size_t path_length) const
+ErrorOr<NonnullOwnPtr<KString>> Process::get_syscall_path_argument(Userspace<char const*> user_path, size_t path_length) const
 {
     if (path_length == 0)
         return EINVAL;
@@ -539,7 +538,7 @@ KResultOr<NonnullOwnPtr<KString>> Process::get_syscall_path_argument(Userspace<c
     return try_copy_kstring_from_user(user_path, path_length);
 }
 
-KResultOr<NonnullOwnPtr<KString>> Process::get_syscall_path_argument(Syscall::StringArgument const& path) const
+ErrorOr<NonnullOwnPtr<KString>> Process::get_syscall_path_argument(Syscall::StringArgument const& path) const
 {
     Userspace<char const*> path_characters((FlatPtr)path.characters);
     return get_syscall_path_argument(path_characters, path.length);
@@ -734,7 +733,7 @@ void Process::terminate_due_to_signal(u8 signal)
     die();
 }
 
-KResult Process::send_signal(u8 signal, Process* sender)
+ErrorOr<void> Process::send_signal(u8 signal, Process* sender)
 {
     // Try to send it to the "obvious" main thread:
     auto receiver_thread = Thread::from_tid(pid().value());
@@ -749,7 +748,7 @@ KResult Process::send_signal(u8 signal, Process* sender)
     }
     if (receiver_thread) {
         receiver_thread->send_signal(signal, sender);
-        return KSuccess;
+        return {};
     }
     return ESRCH;
 }
@@ -799,10 +798,10 @@ void Process::set_tty(TTY* tty)
     m_tty = tty;
 }
 
-KResult Process::start_tracing_from(ProcessID tracer)
+ErrorOr<void> Process::start_tracing_from(ProcessID tracer)
 {
     m_tracer = TRY(ThreadTracer::try_create(tracer));
-    return KSuccess;
+    return {};
 }
 
 void Process::stop_tracing()
@@ -861,7 +860,7 @@ void Process::set_dumpable(bool dumpable)
     m_protected_values.dumpable = dumpable;
 }
 
-KResult Process::set_coredump_property(NonnullOwnPtr<KString> key, NonnullOwnPtr<KString> value)
+ErrorOr<void> Process::set_coredump_property(NonnullOwnPtr<KString> key, NonnullOwnPtr<KString> value)
 {
     // Write it into the first available property slot.
     for (auto& slot : m_coredump_properties) {
@@ -869,12 +868,12 @@ KResult Process::set_coredump_property(NonnullOwnPtr<KString> key, NonnullOwnPtr
             continue;
         slot.key = move(key);
         slot.value = move(value);
-        return KSuccess;
+        return {};
     }
     return ENOBUFS;
 }
 
-KResult Process::try_set_coredump_property(StringView key, StringView value)
+ErrorOr<void> Process::try_set_coredump_property(StringView key, StringView value)
 {
     auto key_kstring = TRY(KString::try_create(key));
     auto value_kstring = TRY(KString::try_create(value));
diff --git a/Kernel/Process.h b/Kernel/Process.h
index 1806dad3f6f..bb26b29d3c5 100644
--- a/Kernel/Process.h
+++ b/Kernel/Process.h
@@ -179,7 +179,7 @@ public:
     }
 
     static RefPtr<Process> create_kernel_process(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, void (*entry)(void*), void* entry_data = nullptr, u32 affinity = THREAD_AFFINITY_DEFAULT, RegisterProcess do_register = RegisterProcess::Yes);
-    static KResultOr<NonnullRefPtr<Process>> try_create_user_process(RefPtr<Thread>& first_thread, StringView path, UserID, GroupID, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, TTY*);
+    static ErrorOr<NonnullRefPtr<Process>> try_create_user_process(RefPtr<Thread>& first_thread, StringView path, UserID, GroupID, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, TTY*);
     static void register_new(Process&);
 
     bool unref() const;
@@ -260,163 +260,163 @@ public:
 
     ThreadTracer* tracer() { return m_tracer.ptr(); }
     bool is_traced() const { return !!m_tracer; }
-    KResult start_tracing_from(ProcessID tracer);
+    ErrorOr<void> start_tracing_from(ProcessID tracer);
     void stop_tracing();
     void tracer_trap(Thread&, const RegisterState&);
 
-    KResultOr<FlatPtr> sys$emuctl();
-    KResultOr<FlatPtr> sys$yield();
-    KResultOr<FlatPtr> sys$sync();
-    KResultOr<FlatPtr> sys$beep();
-    KResultOr<FlatPtr> sys$get_process_name(Userspace<char*> buffer, size_t buffer_size);
-    KResultOr<FlatPtr> sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length);
-    KResultOr<FlatPtr> sys$create_inode_watcher(u32 flags);
-    KResultOr<FlatPtr> sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params);
-    KResultOr<FlatPtr> sys$inode_watcher_remove_watch(int fd, int wd);
-    KResultOr<FlatPtr> sys$dbgputch(u8);
-    KResultOr<FlatPtr> sys$dbgputstr(Userspace<const char*>, size_t);
-    KResultOr<FlatPtr> sys$dump_backtrace();
-    KResultOr<FlatPtr> sys$gettid();
-    KResultOr<FlatPtr> sys$setsid();
-    KResultOr<FlatPtr> sys$getsid(pid_t);
-    KResultOr<FlatPtr> sys$setpgid(pid_t pid, pid_t pgid);
-    KResultOr<FlatPtr> sys$getpgrp();
-    KResultOr<FlatPtr> sys$getpgid(pid_t);
-    KResultOr<FlatPtr> sys$getuid();
-    KResultOr<FlatPtr> sys$getgid();
-    KResultOr<FlatPtr> sys$geteuid();
-    KResultOr<FlatPtr> sys$getegid();
-    KResultOr<FlatPtr> sys$getpid();
-    KResultOr<FlatPtr> sys$getppid();
-    KResultOr<FlatPtr> sys$getresuid(Userspace<UserID*>, Userspace<UserID*>, Userspace<UserID*>);
-    KResultOr<FlatPtr> sys$getresgid(Userspace<GroupID*>, Userspace<GroupID*>, Userspace<GroupID*>);
-    KResultOr<FlatPtr> sys$umask(mode_t);
-    KResultOr<FlatPtr> sys$open(Userspace<const Syscall::SC_open_params*>);
-    KResultOr<FlatPtr> sys$close(int fd);
-    KResultOr<FlatPtr> sys$read(int fd, Userspace<u8*>, size_t);
-    KResultOr<FlatPtr> sys$pread(int fd, Userspace<u8*>, size_t, off_t);
-    KResultOr<FlatPtr> sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count);
-    KResultOr<FlatPtr> sys$write(int fd, Userspace<const u8*>, size_t);
-    KResultOr<FlatPtr> sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count);
-    KResultOr<FlatPtr> sys$fstat(int fd, Userspace<stat*>);
-    KResultOr<FlatPtr> sys$stat(Userspace<const Syscall::SC_stat_params*>);
-    KResultOr<FlatPtr> sys$lseek(int fd, Userspace<off_t*>, int whence);
-    KResultOr<FlatPtr> sys$ftruncate(int fd, Userspace<off_t*>);
-    KResultOr<FlatPtr> sys$kill(pid_t pid_or_pgid, int sig);
+    ErrorOr<FlatPtr> sys$emuctl();
+    ErrorOr<FlatPtr> sys$yield();
+    ErrorOr<FlatPtr> sys$sync();
+    ErrorOr<FlatPtr> sys$beep();
+    ErrorOr<FlatPtr> sys$get_process_name(Userspace<char*> buffer, size_t buffer_size);
+    ErrorOr<FlatPtr> sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length);
+    ErrorOr<FlatPtr> sys$create_inode_watcher(u32 flags);
+    ErrorOr<FlatPtr> sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params);
+    ErrorOr<FlatPtr> sys$inode_watcher_remove_watch(int fd, int wd);
+    ErrorOr<FlatPtr> sys$dbgputch(u8);
+    ErrorOr<FlatPtr> sys$dbgputstr(Userspace<const char*>, size_t);
+    ErrorOr<FlatPtr> sys$dump_backtrace();
+    ErrorOr<FlatPtr> sys$gettid();
+    ErrorOr<FlatPtr> sys$setsid();
+    ErrorOr<FlatPtr> sys$getsid(pid_t);
+    ErrorOr<FlatPtr> sys$setpgid(pid_t pid, pid_t pgid);
+    ErrorOr<FlatPtr> sys$getpgrp();
+    ErrorOr<FlatPtr> sys$getpgid(pid_t);
+    ErrorOr<FlatPtr> sys$getuid();
+    ErrorOr<FlatPtr> sys$getgid();
+    ErrorOr<FlatPtr> sys$geteuid();
+    ErrorOr<FlatPtr> sys$getegid();
+    ErrorOr<FlatPtr> sys$getpid();
+    ErrorOr<FlatPtr> sys$getppid();
+    ErrorOr<FlatPtr> sys$getresuid(Userspace<UserID*>, Userspace<UserID*>, Userspace<UserID*>);
+    ErrorOr<FlatPtr> sys$getresgid(Userspace<GroupID*>, Userspace<GroupID*>, Userspace<GroupID*>);
+    ErrorOr<FlatPtr> sys$umask(mode_t);
+    ErrorOr<FlatPtr> sys$open(Userspace<const Syscall::SC_open_params*>);
+    ErrorOr<FlatPtr> sys$close(int fd);
+    ErrorOr<FlatPtr> sys$read(int fd, Userspace<u8*>, size_t);
+    ErrorOr<FlatPtr> sys$pread(int fd, Userspace<u8*>, size_t, off_t);
+    ErrorOr<FlatPtr> sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count);
+    ErrorOr<FlatPtr> sys$write(int fd, Userspace<const u8*>, size_t);
+    ErrorOr<FlatPtr> sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count);
+    ErrorOr<FlatPtr> sys$fstat(int fd, Userspace<stat*>);
+    ErrorOr<FlatPtr> sys$stat(Userspace<const Syscall::SC_stat_params*>);
+    ErrorOr<FlatPtr> sys$lseek(int fd, Userspace<off_t*>, int whence);
+    ErrorOr<FlatPtr> sys$ftruncate(int fd, Userspace<off_t*>);
+    ErrorOr<FlatPtr> sys$kill(pid_t pid_or_pgid, int sig);
     [[noreturn]] void sys$exit(int status);
-    KResultOr<FlatPtr> sys$sigreturn(RegisterState& registers);
-    KResultOr<FlatPtr> sys$waitid(Userspace<const Syscall::SC_waitid_params*>);
-    KResultOr<FlatPtr> sys$mmap(Userspace<const Syscall::SC_mmap_params*>);
-    KResultOr<FlatPtr> sys$mremap(Userspace<const Syscall::SC_mremap_params*>);
-    KResultOr<FlatPtr> sys$munmap(Userspace<void*>, size_t);
-    KResultOr<FlatPtr> sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*>);
-    KResultOr<FlatPtr> sys$mprotect(Userspace<void*>, size_t, int prot);
-    KResultOr<FlatPtr> sys$madvise(Userspace<void*>, size_t, int advice);
-    KResultOr<FlatPtr> sys$msyscall(Userspace<void*>);
-    KResultOr<FlatPtr> sys$purge(int mode);
-    KResultOr<FlatPtr> sys$select(Userspace<const Syscall::SC_select_params*>);
-    KResultOr<FlatPtr> sys$poll(Userspace<const Syscall::SC_poll_params*>);
-    KResultOr<FlatPtr> sys$get_dir_entries(int fd, Userspace<void*>, size_t);
-    KResultOr<FlatPtr> sys$getcwd(Userspace<char*>, size_t);
-    KResultOr<FlatPtr> sys$chdir(Userspace<const char*>, size_t);
-    KResultOr<FlatPtr> sys$fchdir(int fd);
-    KResultOr<FlatPtr> sys$adjtime(Userspace<const timeval*>, Userspace<timeval*>);
-    KResultOr<FlatPtr> sys$clock_gettime(clockid_t, Userspace<timespec*>);
-    KResultOr<FlatPtr> sys$clock_settime(clockid_t, Userspace<const timespec*>);
-    KResultOr<FlatPtr> sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*>);
-    KResultOr<FlatPtr> sys$gethostname(Userspace<char*>, size_t);
-    KResultOr<FlatPtr> sys$sethostname(Userspace<const char*>, size_t);
-    KResultOr<FlatPtr> sys$uname(Userspace<utsname*>);
-    KResultOr<FlatPtr> sys$readlink(Userspace<const Syscall::SC_readlink_params*>);
-    KResultOr<FlatPtr> sys$ttyname(int fd, Userspace<char*>, size_t);
-    KResultOr<FlatPtr> sys$ptsname(int fd, Userspace<char*>, size_t);
-    KResultOr<FlatPtr> sys$fork(RegisterState&);
-    KResultOr<FlatPtr> sys$execve(Userspace<const Syscall::SC_execve_params*>);
-    KResultOr<FlatPtr> sys$dup2(int old_fd, int new_fd);
-    KResultOr<FlatPtr> sys$sigaction(int signum, Userspace<const sigaction*> act, Userspace<sigaction*> old_act);
-    KResultOr<FlatPtr> sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set);
-    KResultOr<FlatPtr> sys$sigpending(Userspace<sigset_t*>);
-    KResultOr<FlatPtr> sys$getgroups(size_t, Userspace<gid_t*>);
-    KResultOr<FlatPtr> sys$setgroups(size_t, Userspace<const gid_t*>);
-    KResultOr<FlatPtr> sys$pipe(int pipefd[2], int flags);
-    KResultOr<FlatPtr> sys$killpg(pid_t pgrp, int sig);
-    KResultOr<FlatPtr> sys$seteuid(UserID);
-    KResultOr<FlatPtr> sys$setegid(GroupID);
-    KResultOr<FlatPtr> sys$setuid(UserID);
-    KResultOr<FlatPtr> sys$setgid(GroupID);
-    KResultOr<FlatPtr> sys$setreuid(UserID, UserID);
-    KResultOr<FlatPtr> sys$setresuid(UserID, UserID, UserID);
-    KResultOr<FlatPtr> sys$setresgid(GroupID, GroupID, GroupID);
-    KResultOr<FlatPtr> sys$alarm(unsigned seconds);
-    KResultOr<FlatPtr> sys$access(Userspace<const char*> pathname, size_t path_length, int mode);
-    KResultOr<FlatPtr> sys$fcntl(int fd, int cmd, u32 extra_arg);
-    KResultOr<FlatPtr> sys$ioctl(int fd, unsigned request, FlatPtr arg);
-    KResultOr<FlatPtr> sys$mkdir(Userspace<const char*> pathname, size_t path_length, mode_t mode);
-    KResultOr<FlatPtr> sys$times(Userspace<tms*>);
-    KResultOr<FlatPtr> sys$utime(Userspace<const char*> pathname, size_t path_length, Userspace<const struct utimbuf*>);
-    KResultOr<FlatPtr> sys$link(Userspace<const Syscall::SC_link_params*>);
-    KResultOr<FlatPtr> sys$unlink(Userspace<const char*> pathname, size_t path_length);
-    KResultOr<FlatPtr> sys$symlink(Userspace<const Syscall::SC_symlink_params*>);
-    KResultOr<FlatPtr> sys$rmdir(Userspace<const char*> pathname, size_t path_length);
-    KResultOr<FlatPtr> sys$mount(Userspace<const Syscall::SC_mount_params*>);
-    KResultOr<FlatPtr> sys$umount(Userspace<const char*> mountpoint, size_t mountpoint_length);
-    KResultOr<FlatPtr> sys$chmod(Userspace<const char*> pathname, size_t path_length, mode_t);
-    KResultOr<FlatPtr> sys$fchmod(int fd, mode_t);
-    KResultOr<FlatPtr> sys$chown(Userspace<const Syscall::SC_chown_params*>);
-    KResultOr<FlatPtr> sys$fchown(int fd, UserID, GroupID);
-    KResultOr<FlatPtr> sys$fsync(int fd);
-    KResultOr<FlatPtr> sys$socket(int domain, int type, int protocol);
-    KResultOr<FlatPtr> sys$bind(int sockfd, Userspace<const sockaddr*> addr, socklen_t);
-    KResultOr<FlatPtr> sys$listen(int sockfd, int backlog);
-    KResultOr<FlatPtr> sys$accept4(Userspace<const Syscall::SC_accept4_params*>);
-    KResultOr<FlatPtr> sys$connect(int sockfd, Userspace<const sockaddr*>, socklen_t);
-    KResultOr<FlatPtr> sys$shutdown(int sockfd, int how);
-    KResultOr<FlatPtr> sys$sendmsg(int sockfd, Userspace<const struct msghdr*>, int flags);
-    KResultOr<FlatPtr> sys$recvmsg(int sockfd, Userspace<struct msghdr*>, int flags);
-    KResultOr<FlatPtr> sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*>);
-    KResultOr<FlatPtr> sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*>);
-    KResultOr<FlatPtr> sys$getsockname(Userspace<const Syscall::SC_getsockname_params*>);
-    KResultOr<FlatPtr> sys$getpeername(Userspace<const Syscall::SC_getpeername_params*>);
-    KResultOr<FlatPtr> sys$socketpair(Userspace<const Syscall::SC_socketpair_params*>);
-    KResultOr<FlatPtr> sys$sched_setparam(pid_t pid, Userspace<const struct sched_param*>);
-    KResultOr<FlatPtr> sys$sched_getparam(pid_t pid, Userspace<struct sched_param*>);
-    KResultOr<FlatPtr> sys$create_thread(void* (*)(void*), Userspace<const Syscall::SC_create_thread_params*>);
+    ErrorOr<FlatPtr> sys$sigreturn(RegisterState& registers);
+    ErrorOr<FlatPtr> sys$waitid(Userspace<const Syscall::SC_waitid_params*>);
+    ErrorOr<FlatPtr> sys$mmap(Userspace<const Syscall::SC_mmap_params*>);
+    ErrorOr<FlatPtr> sys$mremap(Userspace<const Syscall::SC_mremap_params*>);
+    ErrorOr<FlatPtr> sys$munmap(Userspace<void*>, size_t);
+    ErrorOr<FlatPtr> sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*>);
+    ErrorOr<FlatPtr> sys$mprotect(Userspace<void*>, size_t, int prot);
+    ErrorOr<FlatPtr> sys$madvise(Userspace<void*>, size_t, int advice);
+    ErrorOr<FlatPtr> sys$msyscall(Userspace<void*>);
+    ErrorOr<FlatPtr> sys$purge(int mode);
+    ErrorOr<FlatPtr> sys$select(Userspace<const Syscall::SC_select_params*>);
+    ErrorOr<FlatPtr> sys$poll(Userspace<const Syscall::SC_poll_params*>);
+    ErrorOr<FlatPtr> sys$get_dir_entries(int fd, Userspace<void*>, size_t);
+    ErrorOr<FlatPtr> sys$getcwd(Userspace<char*>, size_t);
+    ErrorOr<FlatPtr> sys$chdir(Userspace<const char*>, size_t);
+    ErrorOr<FlatPtr> sys$fchdir(int fd);
+    ErrorOr<FlatPtr> sys$adjtime(Userspace<const timeval*>, Userspace<timeval*>);
+    ErrorOr<FlatPtr> sys$clock_gettime(clockid_t, Userspace<timespec*>);
+    ErrorOr<FlatPtr> sys$clock_settime(clockid_t, Userspace<const timespec*>);
+    ErrorOr<FlatPtr> sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*>);
+    ErrorOr<FlatPtr> sys$gethostname(Userspace<char*>, size_t);
+    ErrorOr<FlatPtr> sys$sethostname(Userspace<const char*>, size_t);
+    ErrorOr<FlatPtr> sys$uname(Userspace<utsname*>);
+    ErrorOr<FlatPtr> sys$readlink(Userspace<const Syscall::SC_readlink_params*>);
+    ErrorOr<FlatPtr> sys$ttyname(int fd, Userspace<char*>, size_t);
+    ErrorOr<FlatPtr> sys$ptsname(int fd, Userspace<char*>, size_t);
+    ErrorOr<FlatPtr> sys$fork(RegisterState&);
+    ErrorOr<FlatPtr> sys$execve(Userspace<const Syscall::SC_execve_params*>);
+    ErrorOr<FlatPtr> sys$dup2(int old_fd, int new_fd);
+    ErrorOr<FlatPtr> sys$sigaction(int signum, Userspace<const sigaction*> act, Userspace<sigaction*> old_act);
+    ErrorOr<FlatPtr> sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set);
+    ErrorOr<FlatPtr> sys$sigpending(Userspace<sigset_t*>);
+    ErrorOr<FlatPtr> sys$getgroups(size_t, Userspace<gid_t*>);
+    ErrorOr<FlatPtr> sys$setgroups(size_t, Userspace<const gid_t*>);
+    ErrorOr<FlatPtr> sys$pipe(int pipefd[2], int flags);
+    ErrorOr<FlatPtr> sys$killpg(pid_t pgrp, int sig);
+    ErrorOr<FlatPtr> sys$seteuid(UserID);
+    ErrorOr<FlatPtr> sys$setegid(GroupID);
+    ErrorOr<FlatPtr> sys$setuid(UserID);
+    ErrorOr<FlatPtr> sys$setgid(GroupID);
+    ErrorOr<FlatPtr> sys$setreuid(UserID, UserID);
+    ErrorOr<FlatPtr> sys$setresuid(UserID, UserID, UserID);
+    ErrorOr<FlatPtr> sys$setresgid(GroupID, GroupID, GroupID);
+    ErrorOr<FlatPtr> sys$alarm(unsigned seconds);
+    ErrorOr<FlatPtr> sys$access(Userspace<const char*> pathname, size_t path_length, int mode);
+    ErrorOr<FlatPtr> sys$fcntl(int fd, int cmd, u32 extra_arg);
+    ErrorOr<FlatPtr> sys$ioctl(int fd, unsigned request, FlatPtr arg);
+    ErrorOr<FlatPtr> sys$mkdir(Userspace<const char*> pathname, size_t path_length, mode_t mode);
+    ErrorOr<FlatPtr> sys$times(Userspace<tms*>);
+    ErrorOr<FlatPtr> sys$utime(Userspace<const char*> pathname, size_t path_length, Userspace<const struct utimbuf*>);
+    ErrorOr<FlatPtr> sys$link(Userspace<const Syscall::SC_link_params*>);
+    ErrorOr<FlatPtr> sys$unlink(Userspace<const char*> pathname, size_t path_length);
+    ErrorOr<FlatPtr> sys$symlink(Userspace<const Syscall::SC_symlink_params*>);
+    ErrorOr<FlatPtr> sys$rmdir(Userspace<const char*> pathname, size_t path_length);
+    ErrorOr<FlatPtr> sys$mount(Userspace<const Syscall::SC_mount_params*>);
+    ErrorOr<FlatPtr> sys$umount(Userspace<const char*> mountpoint, size_t mountpoint_length);
+    ErrorOr<FlatPtr> sys$chmod(Userspace<const char*> pathname, size_t path_length, mode_t);
+    ErrorOr<FlatPtr> sys$fchmod(int fd, mode_t);
+    ErrorOr<FlatPtr> sys$chown(Userspace<const Syscall::SC_chown_params*>);
+    ErrorOr<FlatPtr> sys$fchown(int fd, UserID, GroupID);
+    ErrorOr<FlatPtr> sys$fsync(int fd);
+    ErrorOr<FlatPtr> sys$socket(int domain, int type, int protocol);
+    ErrorOr<FlatPtr> sys$bind(int sockfd, Userspace<const sockaddr*> addr, socklen_t);
+    ErrorOr<FlatPtr> sys$listen(int sockfd, int backlog);
+    ErrorOr<FlatPtr> sys$accept4(Userspace<const Syscall::SC_accept4_params*>);
+    ErrorOr<FlatPtr> sys$connect(int sockfd, Userspace<const sockaddr*>, socklen_t);
+    ErrorOr<FlatPtr> sys$shutdown(int sockfd, int how);
+    ErrorOr<FlatPtr> sys$sendmsg(int sockfd, Userspace<const struct msghdr*>, int flags);
+    ErrorOr<FlatPtr> sys$recvmsg(int sockfd, Userspace<struct msghdr*>, int flags);
+    ErrorOr<FlatPtr> sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*>);
+    ErrorOr<FlatPtr> sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*>);
+    ErrorOr<FlatPtr> sys$getsockname(Userspace<const Syscall::SC_getsockname_params*>);
+    ErrorOr<FlatPtr> sys$getpeername(Userspace<const Syscall::SC_getpeername_params*>);
+    ErrorOr<FlatPtr> sys$socketpair(Userspace<const Syscall::SC_socketpair_params*>);
+    ErrorOr<FlatPtr> sys$sched_setparam(pid_t pid, Userspace<const struct sched_param*>);
+    ErrorOr<FlatPtr> sys$sched_getparam(pid_t pid, Userspace<struct sched_param*>);
+    ErrorOr<FlatPtr> sys$create_thread(void* (*)(void*), Userspace<const Syscall::SC_create_thread_params*>);
     [[noreturn]] void sys$exit_thread(Userspace<void*>, Userspace<void*>, size_t);
-    KResultOr<FlatPtr> sys$join_thread(pid_t tid, Userspace<void**> exit_value);
-    KResultOr<FlatPtr> sys$detach_thread(pid_t tid);
-    KResultOr<FlatPtr> sys$set_thread_name(pid_t tid, Userspace<const char*> buffer, size_t buffer_size);
-    KResultOr<FlatPtr> sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size);
-    KResultOr<FlatPtr> sys$kill_thread(pid_t tid, int signal);
-    KResultOr<FlatPtr> sys$rename(Userspace<const Syscall::SC_rename_params*>);
-    KResultOr<FlatPtr> sys$mknod(Userspace<const Syscall::SC_mknod_params*>);
-    KResultOr<FlatPtr> sys$realpath(Userspace<const Syscall::SC_realpath_params*>);
-    KResultOr<FlatPtr> sys$getrandom(Userspace<void*>, size_t, unsigned int);
-    KResultOr<FlatPtr> sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*>);
-    KResultOr<FlatPtr> sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*>);
-    KResultOr<FlatPtr> sys$profiling_enable(pid_t, u64);
-    KResultOr<FlatPtr> sys$profiling_disable(pid_t);
-    KResultOr<FlatPtr> sys$profiling_free_buffer(pid_t);
-    KResultOr<FlatPtr> sys$futex(Userspace<const Syscall::SC_futex_params*>);
-    KResultOr<FlatPtr> sys$pledge(Userspace<const Syscall::SC_pledge_params*>);
-    KResultOr<FlatPtr> sys$unveil(Userspace<const Syscall::SC_unveil_params*>);
-    KResultOr<FlatPtr> sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2);
-    KResultOr<FlatPtr> sys$perf_register_string(Userspace<char const*>, size_t);
-    KResultOr<FlatPtr> sys$get_stack_bounds(Userspace<FlatPtr*> stack_base, Userspace<size_t*> stack_size);
-    KResultOr<FlatPtr> sys$ptrace(Userspace<const Syscall::SC_ptrace_params*>);
-    KResultOr<FlatPtr> sys$sendfd(int sockfd, int fd);
-    KResultOr<FlatPtr> sys$recvfd(int sockfd, int options);
-    KResultOr<FlatPtr> sys$sysconf(int name);
-    KResultOr<FlatPtr> sys$disown(ProcessID);
-    KResultOr<FlatPtr> sys$allocate_tls(Userspace<const char*> initial_data, size_t);
-    KResultOr<FlatPtr> sys$prctl(int option, FlatPtr arg1, FlatPtr arg2);
-    KResultOr<FlatPtr> sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*>);
-    KResultOr<FlatPtr> sys$anon_create(size_t, int options);
-    KResultOr<FlatPtr> sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params);
-    KResultOr<FlatPtr> sys$fstatvfs(int fd, statvfs* buf);
-    KResultOr<FlatPtr> sys$map_time_page();
+    ErrorOr<FlatPtr> sys$join_thread(pid_t tid, Userspace<void**> exit_value);
+    ErrorOr<FlatPtr> sys$detach_thread(pid_t tid);
+    ErrorOr<FlatPtr> sys$set_thread_name(pid_t tid, Userspace<const char*> buffer, size_t buffer_size);
+    ErrorOr<FlatPtr> sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size);
+    ErrorOr<FlatPtr> sys$kill_thread(pid_t tid, int signal);
+    ErrorOr<FlatPtr> sys$rename(Userspace<const Syscall::SC_rename_params*>);
+    ErrorOr<FlatPtr> sys$mknod(Userspace<const Syscall::SC_mknod_params*>);
+    ErrorOr<FlatPtr> sys$realpath(Userspace<const Syscall::SC_realpath_params*>);
+    ErrorOr<FlatPtr> sys$getrandom(Userspace<void*>, size_t, unsigned int);
+    ErrorOr<FlatPtr> sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*>);
+    ErrorOr<FlatPtr> sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*>);
+    ErrorOr<FlatPtr> sys$profiling_enable(pid_t, u64);
+    ErrorOr<FlatPtr> sys$profiling_disable(pid_t);
+    ErrorOr<FlatPtr> sys$profiling_free_buffer(pid_t);
+    ErrorOr<FlatPtr> sys$futex(Userspace<const Syscall::SC_futex_params*>);
+    ErrorOr<FlatPtr> sys$pledge(Userspace<const Syscall::SC_pledge_params*>);
+    ErrorOr<FlatPtr> sys$unveil(Userspace<const Syscall::SC_unveil_params*>);
+    ErrorOr<FlatPtr> sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2);
+    ErrorOr<FlatPtr> sys$perf_register_string(Userspace<char const*>, size_t);
+    ErrorOr<FlatPtr> sys$get_stack_bounds(Userspace<FlatPtr*> stack_base, Userspace<size_t*> stack_size);
+    ErrorOr<FlatPtr> sys$ptrace(Userspace<const Syscall::SC_ptrace_params*>);
+    ErrorOr<FlatPtr> sys$sendfd(int sockfd, int fd);
+    ErrorOr<FlatPtr> sys$recvfd(int sockfd, int options);
+    ErrorOr<FlatPtr> sys$sysconf(int name);
+    ErrorOr<FlatPtr> sys$disown(ProcessID);
+    ErrorOr<FlatPtr> sys$allocate_tls(Userspace<const char*> initial_data, size_t);
+    ErrorOr<FlatPtr> sys$prctl(int option, FlatPtr arg1, FlatPtr arg2);
+    ErrorOr<FlatPtr> sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*>);
+    ErrorOr<FlatPtr> sys$anon_create(size_t, int options);
+    ErrorOr<FlatPtr> sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params);
+    ErrorOr<FlatPtr> sys$fstatvfs(int fd, statvfs* buf);
+    ErrorOr<FlatPtr> sys$map_time_page();
 
     template<bool sockname, typename Params>
-    KResult get_sock_or_peer_name(Params const&);
+    ErrorOr<void> get_sock_or_peer_name(Params const&);
 
     static void initialize();
 
@@ -439,14 +439,14 @@ public:
     NonnullOwnPtrVector<KString> const& arguments() const { return m_arguments; };
     NonnullOwnPtrVector<KString> const& environment() const { return m_environment; };
 
-    KResult exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, int recusion_depth = 0);
+    ErrorOr<void> exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, int recusion_depth = 0);
 
-    KResultOr<LoadResult> load(NonnullRefPtr<OpenFileDescription> main_program_description, RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header);
+    ErrorOr<LoadResult> load(NonnullRefPtr<OpenFileDescription> main_program_description, RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header);
 
     bool is_superuser() const { return euid() == 0; }
 
     void terminate_due_to_signal(u8 signal);
-    KResult send_signal(u8 signal, Process* sender);
+    ErrorOr<void> send_signal(u8 signal, Process* sender);
 
     u8 termination_signal() const { return m_protected_values.termination_signal; }
 
@@ -479,8 +479,8 @@ public:
         m_wait_for_tracer_at_next_execve = val;
     }
 
-    KResultOr<u32> peek_user_data(Userspace<const u32*> address);
-    KResult poke_user_data(Userspace<u32*> address, u32 data);
+    ErrorOr<u32> peek_user_data(Userspace<const u32*> address);
+    ErrorOr<void> poke_user_data(Userspace<u32*> address, u32 data);
 
     void disowned_by_waiter(Process& process);
     void unblock_waiters(Thread::WaitBlocker::UnblockFlags, u8 signal = 0);
@@ -495,8 +495,8 @@ public:
         }
     }
 
-    KResult set_coredump_property(NonnullOwnPtr<KString> key, NonnullOwnPtr<KString> value);
-    KResult try_set_coredump_property(StringView key, StringView value);
+    ErrorOr<void> set_coredump_property(NonnullOwnPtr<KString> key, NonnullOwnPtr<KString> value);
+    ErrorOr<void> try_set_coredump_property(StringView key, StringView value);
 
     const NonnullRefPtrVector<Thread>& threads_for_coredump(Badge<Coredump>) const { return m_threads_for_coredump; }
 
@@ -521,8 +521,8 @@ private:
     bool remove_thread(Thread&);
 
     Process(NonnullOwnPtr<KString> name, UserID, GroupID, ProcessID ppid, bool is_kernel_process, RefPtr<Custody> cwd, RefPtr<Custody> executable, TTY* tty);
-    static KResultOr<NonnullRefPtr<Process>> try_create(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, UserID, GroupID, ProcessID ppid, bool is_kernel_process, RefPtr<Custody> cwd = nullptr, RefPtr<Custody> executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr);
-    KResult attach_resources(NonnullOwnPtr<Memory::AddressSpace>&&, RefPtr<Thread>& first_thread, Process* fork_parent);
+    static ErrorOr<NonnullRefPtr<Process>> try_create(RefPtr<Thread>& first_thread, NonnullOwnPtr<KString> name, UserID, GroupID, ProcessID ppid, bool is_kernel_process, RefPtr<Custody> cwd = nullptr, RefPtr<Custody> executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr);
+    ErrorOr<void> attach_resources(NonnullOwnPtr<Memory::AddressSpace>&&, RefPtr<Thread>& first_thread, Process* fork_parent);
     static ProcessID allocate_pid();
 
     void kill_threads_except_self();
@@ -532,22 +532,22 @@ private:
     bool create_perf_events_buffer_if_needed();
     void delete_perf_events_buffer();
 
-    KResult do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const ElfW(Ehdr) & main_program_header);
-    KResultOr<FlatPtr> do_write(OpenFileDescription&, const UserOrKernelBuffer&, size_t);
+    ErrorOr<void> do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const ElfW(Ehdr) & main_program_header);
+    ErrorOr<FlatPtr> do_write(OpenFileDescription&, const UserOrKernelBuffer&, size_t);
 
-    KResultOr<FlatPtr> do_statvfs(StringView path, statvfs* buf);
+    ErrorOr<FlatPtr> do_statvfs(StringView path, statvfs* buf);
 
-    KResultOr<RefPtr<OpenFileDescription>> find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size);
+    ErrorOr<RefPtr<OpenFileDescription>> find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size);
 
-    KResult do_kill(Process&, int signal);
-    KResult do_killpg(ProcessGroupID pgrp, int signal);
-    KResult do_killall(int signal);
-    KResult do_killself(int signal);
+    ErrorOr<void> do_kill(Process&, int signal);
+    ErrorOr<void> do_killpg(ProcessGroupID pgrp, int signal);
+    ErrorOr<void> do_killall(int signal);
+    ErrorOr<void> do_killself(int signal);
 
-    KResultOr<siginfo_t> do_waitid(Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, int options);
+    ErrorOr<siginfo_t> do_waitid(Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, int options);
 
-    KResultOr<NonnullOwnPtr<KString>> get_syscall_path_argument(Userspace<const char*> user_path, size_t path_length) const;
-    KResultOr<NonnullOwnPtr<KString>> get_syscall_path_argument(const Syscall::StringArgument&) const;
+    ErrorOr<NonnullOwnPtr<KString>> get_syscall_path_argument(Userspace<const char*> user_path, size_t path_length) const;
+    ErrorOr<NonnullOwnPtr<KString>> get_syscall_path_argument(const Syscall::StringArgument&) const;
 
     bool has_tracee_thread(ProcessID tracer_pid);
 
@@ -557,20 +557,20 @@ private:
 
 public:
     NonnullRefPtr<ProcessProcFSTraits> procfs_traits() const { return *m_procfs_traits; }
-    KResult procfs_get_fds_stats(KBufferBuilder& builder) const;
-    KResult procfs_get_perf_events(KBufferBuilder& builder) const;
-    KResult procfs_get_unveil_stats(KBufferBuilder& builder) const;
-    KResult procfs_get_pledge_stats(KBufferBuilder& builder) const;
-    KResult procfs_get_virtual_memory_stats(KBufferBuilder& builder) const;
-    KResult procfs_get_binary_link(KBufferBuilder& builder) const;
-    KResult procfs_get_current_work_directory_link(KBufferBuilder& builder) const;
+    ErrorOr<void> procfs_get_fds_stats(KBufferBuilder& builder) const;
+    ErrorOr<void> procfs_get_perf_events(KBufferBuilder& builder) const;
+    ErrorOr<void> procfs_get_unveil_stats(KBufferBuilder& builder) const;
+    ErrorOr<void> procfs_get_pledge_stats(KBufferBuilder& builder) const;
+    ErrorOr<void> procfs_get_virtual_memory_stats(KBufferBuilder& builder) const;
+    ErrorOr<void> procfs_get_binary_link(KBufferBuilder& builder) const;
+    ErrorOr<void> procfs_get_current_work_directory_link(KBufferBuilder& builder) const;
     mode_t binary_link_required_mode() const;
-    KResultOr<size_t> procfs_get_thread_stack(ThreadID thread_id, KBufferBuilder& builder) const;
-    KResult traverse_stacks_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const;
-    KResultOr<NonnullRefPtr<Inode>> lookup_stacks_directory(const ProcFS&, StringView name) const;
-    KResultOr<size_t> procfs_get_file_description_link(unsigned fd, KBufferBuilder& builder) const;
-    KResult traverse_file_descriptions_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const;
-    KResultOr<NonnullRefPtr<Inode>> lookup_file_descriptions_directory(const ProcFS&, StringView name) const;
+    ErrorOr<size_t> procfs_get_thread_stack(ThreadID thread_id, KBufferBuilder& builder) const;
+    ErrorOr<void> traverse_stacks_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const;
+    ErrorOr<NonnullRefPtr<Inode>> lookup_stacks_directory(const ProcFS&, StringView name) const;
+    ErrorOr<size_t> procfs_get_file_description_link(unsigned fd, KBufferBuilder& builder) const;
+    ErrorOr<void> traverse_file_descriptions_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const;
+    ErrorOr<NonnullRefPtr<Inode>> lookup_file_descriptions_directory(const ProcFS&, StringView name) const;
 
 private:
     inline PerformanceEventBuffer* current_perf_events_buffer()
@@ -638,7 +638,7 @@ public:
         ALWAYS_INLINE const OpenFileDescriptionAndFlags& operator[](size_t i) const { return at(i); }
         ALWAYS_INLINE OpenFileDescriptionAndFlags& operator[](size_t i) { return at(i); }
 
-        KResult try_clone(const Kernel::Process::OpenFileDescriptions& other)
+        ErrorOr<void> try_clone(const Kernel::Process::OpenFileDescriptions& other)
         {
             SpinlockLocker lock_other(other.m_fds_lock);
             if (!try_resize(other.m_fds_metadatas.size()))
@@ -647,7 +647,7 @@ public:
             for (size_t i = 0; i < other.m_fds_metadatas.size(); ++i) {
                 m_fds_metadatas[i] = other.m_fds_metadatas[i];
             }
-            return KSuccess;
+            return {};
         }
 
         const OpenFileDescriptionAndFlags& at(size_t i) const;
@@ -659,7 +659,7 @@ public:
         void enumerate(Function<void(const OpenFileDescriptionAndFlags&)>) const;
         void change_each(Function<void(OpenFileDescriptionAndFlags&)>);
 
-        KResultOr<ScopedDescriptionAllocation> allocate(int first_candidate_fd = 0);
+        ErrorOr<ScopedDescriptionAllocation> allocate(int first_candidate_fd = 0);
         size_t open_count() const;
 
         bool try_resize(size_t size) { return m_fds_metadatas.try_resize(size); }
@@ -675,7 +675,7 @@ public:
             m_fds_metadatas.clear();
         }
 
-        KResultOr<NonnullRefPtr<OpenFileDescription>> open_file_description(int fd) const;
+        ErrorOr<NonnullRefPtr<OpenFileDescription>> open_file_description(int fd) const;
 
     private:
         OpenFileDescriptions() = default;
@@ -717,14 +717,14 @@ public:
 
     class ProcessProcFSTraits : public ProcFSExposedComponent {
     public:
-        static KResultOr<NonnullRefPtr<ProcessProcFSTraits>> try_create(Badge<Process>, Process& process)
+        static ErrorOr<NonnullRefPtr<ProcessProcFSTraits>> try_create(Badge<Process>, Process& process)
         {
             return adopt_nonnull_ref_or_enomem(new (nothrow) ProcessProcFSTraits(process));
         }
 
         virtual InodeIndex component_index() const override;
-        virtual KResultOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const override;
-        virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+        virtual ErrorOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const override;
+        virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
         virtual mode_t required_mode() const override { return 0555; }
 
         virtual UserID owner_user() const override;
@@ -974,7 +974,7 @@ inline ProcessID Thread::pid() const
 #define VERIFY_NO_PROCESS_BIG_LOCK(process) \
     VERIFY(!process->big_lock().is_locked_by_current_thread());
 
-inline static KResultOr<NonnullOwnPtr<KString>> try_copy_kstring_from_user(const Kernel::Syscall::StringArgument& string)
+inline static ErrorOr<NonnullOwnPtr<KString>> try_copy_kstring_from_user(const Kernel::Syscall::StringArgument& string)
 {
     Userspace<char const*> characters((FlatPtr)string.characters);
     return try_copy_kstring_from_user(characters, string.length);
diff --git a/Kernel/ProcessExposed.cpp b/Kernel/ProcessExposed.cpp
index 7db390ea9d4..d3d188bc9af 100644
--- a/Kernel/ProcessExposed.cpp
+++ b/Kernel/ProcessExposed.cpp
@@ -107,7 +107,7 @@ ProcFSExposedLink::ProcFSExposedLink(StringView name)
     : ProcFSExposedComponent(name)
 {
 }
-KResultOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
+ErrorOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const
 {
     dbgln_if(PROCFS_DEBUG, "ProcFSGlobalInformation @ {}: read_bytes offset: {} count: {}", name(), offset, count);
 
@@ -115,13 +115,13 @@ KResultOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count
     VERIFY(buffer.user_or_kernel_ptr());
 
     if (!description)
-        return KResult(EIO);
+        return Error::from_errno(EIO);
 
     MutexLocker locker(m_refresh_lock);
 
     if (!description->data()) {
         dbgln("ProcFSGlobalInformation: Do not have cached data!");
-        return KResult(EIO);
+        return Error::from_errno(EIO);
     }
 
     auto& typed_cached_data = static_cast<ProcFSInodeData&>(*description->data());
@@ -135,7 +135,7 @@ KResultOr<size_t> ProcFSGlobalInformation::read_bytes(off_t offset, size_t count
     return nread;
 }
 
-KResult ProcFSGlobalInformation::refresh_data(OpenFileDescription& description) const
+ErrorOr<void> ProcFSGlobalInformation::refresh_data(OpenFileDescription& description) const
 {
     MutexLocker lock(m_refresh_lock);
     auto& cached_data = description.data();
@@ -150,15 +150,15 @@ KResult ProcFSGlobalInformation::refresh_data(OpenFileDescription& description)
     typed_cached_data.buffer = builder.build();
     if (!typed_cached_data.buffer)
         return ENOMEM;
-    return KSuccess;
+    return {};
 }
 
-KResult ProcFSSystemBoolean::try_generate(KBufferBuilder& builder)
+ErrorOr<void> ProcFSSystemBoolean::try_generate(KBufferBuilder& builder)
 {
     return builder.appendff("{}\n", static_cast<int>(value()));
 }
 
-KResultOr<size_t> ProcFSSystemBoolean::write_bytes(off_t, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription*)
+ErrorOr<size_t> ProcFSSystemBoolean::write_bytes(off_t, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription*)
 {
     if (count != 1)
         return EINVAL;
@@ -174,45 +174,45 @@ KResultOr<size_t> ProcFSSystemBoolean::write_bytes(off_t, size_t count, const Us
     return 1;
 }
 
-KResult ProcFSSystemBoolean::truncate(u64 size)
+ErrorOr<void> ProcFSSystemBoolean::truncate(u64 size)
 {
     if (size != 0)
         return EPERM;
-    return KSuccess;
+    return {};
 }
 
-KResult ProcFSSystemBoolean::set_mtime(time_t)
+ErrorOr<void> ProcFSSystemBoolean::set_mtime(time_t)
 {
-    return KSuccess;
+    return {};
 }
 
-KResultOr<size_t> ProcFSExposedLink::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
+ErrorOr<size_t> ProcFSExposedLink::read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription*) const
 {
     VERIFY(offset == 0);
     MutexLocker locker(m_lock);
     auto builder = TRY(KBufferBuilder::try_create());
     if (!const_cast<ProcFSExposedLink&>(*this).acquire_link(builder))
-        return KResult(EFAULT);
+        return Error::from_errno(EFAULT);
     auto blob = builder.build();
     if (!blob)
-        return KResult(EFAULT);
+        return Error::from_errno(EFAULT);
 
     ssize_t nread = min(static_cast<off_t>(blob->size() - offset), static_cast<off_t>(count));
     TRY(buffer.write(blob->data() + offset, nread));
     return nread;
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSExposedLink::to_inode(const ProcFS& procfs_instance) const
+ErrorOr<NonnullRefPtr<Inode>> ProcFSExposedLink::to_inode(const ProcFS& procfs_instance) const
 {
     return TRY(ProcFSLinkInode::try_create(procfs_instance, *this));
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSExposedComponent::to_inode(const ProcFS& procfs_instance) const
+ErrorOr<NonnullRefPtr<Inode>> ProcFSExposedComponent::to_inode(const ProcFS& procfs_instance) const
 {
     return TRY(ProcFSGlobalInode::try_create(procfs_instance, *this));
 }
 
-KResultOr<NonnullRefPtr<Inode>> ProcFSExposedDirectory::to_inode(const ProcFS& procfs_instance) const
+ErrorOr<NonnullRefPtr<Inode>> ProcFSExposedDirectory::to_inode(const ProcFS& procfs_instance) const
 {
     return TRY(ProcFSDirectoryInode::try_create(procfs_instance, *this));
 }
@@ -222,7 +222,7 @@ void ProcFSExposedDirectory::add_component(const ProcFSExposedComponent&)
     TODO();
 }
 
-KResultOr<NonnullRefPtr<ProcFSExposedComponent>> ProcFSExposedDirectory::lookup(StringView name)
+ErrorOr<NonnullRefPtr<ProcFSExposedComponent>> ProcFSExposedDirectory::lookup(StringView name)
 {
     for (auto& component : m_components) {
         if (component.name() == name) {
@@ -232,12 +232,12 @@ KResultOr<NonnullRefPtr<ProcFSExposedComponent>> ProcFSExposedDirectory::lookup(
     return ENOENT;
 }
 
-KResult ProcFSExposedDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> ProcFSExposedDirectory::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     MutexLocker locker(ProcFSComponentRegistry::the().get_lock());
     auto parent_directory = m_parent_directory.strong_ref();
     if (parent_directory.is_null())
-        return KResult(EINVAL);
+        return Error::from_errno(EINVAL);
     callback({ ".", { fsid, component_index() }, DT_DIR });
     callback({ "..", { fsid, parent_directory->component_index() }, DT_DIR });
 
@@ -245,7 +245,7 @@ KResult ProcFSExposedDirectory::traverse_as_directory(unsigned fsid, Function<bo
         InodeIdentifier identifier = { fsid, component.component_index() };
         callback({ component.name(), identifier, 0 });
     }
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/ProcessExposed.h b/Kernel/ProcessExposed.h
index 6cb43247345..d46579e035f 100644
--- a/Kernel/ProcessExposed.h
+++ b/Kernel/ProcessExposed.h
@@ -6,12 +6,12 @@
 
 #pragma once
 
+#include <AK/Error.h>
 #include <AK/Function.h>
 #include <AK/RefCounted.h>
 #include <AK/RefPtr.h>
 #include <AK/String.h>
 #include <AK/Types.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Arch/x86/CPU.h>
 #include <Kernel/FileSystem/File.h>
 #include <Kernel/FileSystem/FileSystem.h>
@@ -66,12 +66,12 @@ private:
 class ProcFSExposedComponent : public RefCounted<ProcFSExposedComponent> {
 public:
     StringView name() const { return m_name->view(); }
-    virtual KResultOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const { VERIFY_NOT_REACHED(); }
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const { VERIFY_NOT_REACHED(); }
-    virtual KResultOr<NonnullRefPtr<ProcFSExposedComponent>> lookup(StringView) { VERIFY_NOT_REACHED(); };
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*) { return EROFS; }
-    virtual KResult truncate(u64) { return EPERM; }
-    virtual KResult set_mtime(time_t) { return ENOTIMPL; }
+    virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer&, OpenFileDescription*) const { VERIFY_NOT_REACHED(); }
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const { VERIFY_NOT_REACHED(); }
+    virtual ErrorOr<NonnullRefPtr<ProcFSExposedComponent>> lookup(StringView) { VERIFY_NOT_REACHED(); };
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*) { return EROFS; }
+    virtual ErrorOr<void> truncate(u64) { return EPERM; }
+    virtual ErrorOr<void> set_mtime(time_t) { return ENOTIMPL; }
 
     virtual mode_t required_mode() const { return 0444; }
     virtual UserID owner_user() const { return 0; }
@@ -79,12 +79,12 @@ public:
     time_t modified_time() const { return TimeManagement::now().to_timeval().tv_sec; }
 
     virtual void prepare_for_deletion() { }
-    virtual KResult refresh_data(OpenFileDescription&) const
+    virtual ErrorOr<void> refresh_data(OpenFileDescription&) const
     {
-        return KSuccess;
+        return {};
     }
 
-    virtual KResultOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const;
+    virtual ErrorOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const;
 
     virtual InodeIndex component_index() const { return m_component_index; }
 
@@ -105,8 +105,8 @@ class ProcFSExposedDirectory
     friend class ProcFSComponentRegistry;
 
 public:
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
-    virtual KResultOr<NonnullRefPtr<ProcFSExposedComponent>> lookup(StringView name) override;
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<NonnullRefPtr<ProcFSExposedComponent>> lookup(StringView name) override;
     void add_component(const ProcFSExposedComponent&);
 
     virtual void prepare_for_deletion() override
@@ -117,7 +117,7 @@ public:
     }
     virtual mode_t required_mode() const override { return 0555; }
 
-    virtual KResultOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const override final;
+    virtual ErrorOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const override final;
 
 protected:
     explicit ProcFSExposedDirectory(StringView name);
@@ -128,9 +128,9 @@ protected:
 
 class ProcFSExposedLink : public ProcFSExposedComponent {
 public:
-    virtual KResultOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const override final;
+    virtual ErrorOr<NonnullRefPtr<Inode>> to_inode(const ProcFS& procfs_instance) const override final;
 
-    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const override;
 
 protected:
     virtual bool acquire_link(KBufferBuilder& builder) = 0;
@@ -142,12 +142,12 @@ class ProcFSRootDirectory final : public ProcFSExposedDirectory {
     friend class ProcFSComponentRegistry;
 
 public:
-    virtual KResultOr<NonnullRefPtr<ProcFSExposedComponent>> lookup(StringView name) override;
+    virtual ErrorOr<NonnullRefPtr<ProcFSExposedComponent>> lookup(StringView name) override;
     static NonnullRefPtr<ProcFSRootDirectory> must_create();
     virtual ~ProcFSRootDirectory();
 
 private:
-    virtual KResult traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
+    virtual ErrorOr<void> traverse_as_directory(unsigned, Function<bool(FileSystem::DirectoryEntryView const&)>) const override;
     ProcFSRootDirectory();
 };
 
@@ -159,7 +159,7 @@ class ProcFSGlobalInformation : public ProcFSExposedComponent {
 public:
     virtual ~ProcFSGlobalInformation() override {};
 
-    virtual KResultOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const override;
+    virtual ErrorOr<size_t> read_bytes(off_t offset, size_t count, UserOrKernelBuffer& buffer, OpenFileDescription* description) const override;
 
     virtual mode_t required_mode() const override { return 0444; }
 
@@ -168,8 +168,8 @@ protected:
         : ProcFSExposedComponent(name)
     {
     }
-    virtual KResult refresh_data(OpenFileDescription&) const override;
-    virtual KResult try_generate(KBufferBuilder&) = 0;
+    virtual ErrorOr<void> refresh_data(OpenFileDescription&) const override;
+    virtual ErrorOr<void> try_generate(KBufferBuilder&) = 0;
 
     mutable Mutex m_refresh_lock;
 };
@@ -187,13 +187,13 @@ protected:
 
 private:
     // ^ProcFSGlobalInformation
-    virtual KResult try_generate(KBufferBuilder&) override final;
+    virtual ErrorOr<void> try_generate(KBufferBuilder&) override final;
 
     // ^ProcFSExposedComponent
-    virtual KResultOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*) override final;
+    virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*) override final;
     virtual mode_t required_mode() const override final { return 0644; }
-    virtual KResult truncate(u64) override final;
-    virtual KResult set_mtime(time_t) override final;
+    virtual ErrorOr<void> truncate(u64) override final;
+    virtual ErrorOr<void> set_mtime(time_t) override final;
 };
 
 }
diff --git a/Kernel/ProcessGroup.cpp b/Kernel/ProcessGroup.cpp
index 086cf3491ac..d9b6aa60b89 100644
--- a/Kernel/ProcessGroup.cpp
+++ b/Kernel/ProcessGroup.cpp
@@ -24,7 +24,7 @@ ProcessGroup::~ProcessGroup()
     });
 }
 
-KResultOr<NonnullRefPtr<ProcessGroup>> ProcessGroup::try_create(ProcessGroupID pgid)
+ErrorOr<NonnullRefPtr<ProcessGroup>> ProcessGroup::try_create(ProcessGroupID pgid)
 {
     auto process_group = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) ProcessGroup(pgid)));
     process_groups().with([&](auto& groups) {
@@ -33,9 +33,9 @@ KResultOr<NonnullRefPtr<ProcessGroup>> ProcessGroup::try_create(ProcessGroupID p
     return process_group;
 }
 
-KResultOr<NonnullRefPtr<ProcessGroup>> ProcessGroup::try_find_or_create(ProcessGroupID pgid)
+ErrorOr<NonnullRefPtr<ProcessGroup>> ProcessGroup::try_find_or_create(ProcessGroupID pgid)
 {
-    return process_groups().with([&](auto& groups) -> KResultOr<NonnullRefPtr<ProcessGroup>> {
+    return process_groups().with([&](auto& groups) -> ErrorOr<NonnullRefPtr<ProcessGroup>> {
         for (auto& group : groups) {
             if (group.pgid() == pgid)
                 return group;
diff --git a/Kernel/ProcessGroup.h b/Kernel/ProcessGroup.h
index de5bf0ed215..5d9309ceb8a 100644
--- a/Kernel/ProcessGroup.h
+++ b/Kernel/ProcessGroup.h
@@ -24,8 +24,8 @@ class ProcessGroup
 public:
     ~ProcessGroup();
 
-    static KResultOr<NonnullRefPtr<ProcessGroup>> try_create(ProcessGroupID);
-    static KResultOr<NonnullRefPtr<ProcessGroup>> try_find_or_create(ProcessGroupID);
+    static ErrorOr<NonnullRefPtr<ProcessGroup>> try_create(ProcessGroupID);
+    static ErrorOr<NonnullRefPtr<ProcessGroup>> try_find_or_create(ProcessGroupID);
     static RefPtr<ProcessGroup> from_pgid(ProcessGroupID);
 
     const ProcessGroupID& pgid() const { return m_pgid; }
diff --git a/Kernel/ProcessProcFSTraits.cpp b/Kernel/ProcessProcFSTraits.cpp
index 2fdb453aaa7..d9592f4744f 100644
--- a/Kernel/ProcessProcFSTraits.cpp
+++ b/Kernel/ProcessProcFSTraits.cpp
@@ -36,7 +36,7 @@ InodeIndex Process::ProcessProcFSTraits::component_index() const
     return SegmentedProcFSIndex::build_segmented_index_for_pid_directory(process->pid());
 }
 
-KResultOr<NonnullRefPtr<Inode>> Process::ProcessProcFSTraits::to_inode(const ProcFS& procfs_instance) const
+ErrorOr<NonnullRefPtr<Inode>> Process::ProcessProcFSTraits::to_inode(const ProcFS& procfs_instance) const
 {
     auto process = m_process.strong_ref();
     if (!process)
@@ -45,7 +45,7 @@ KResultOr<NonnullRefPtr<Inode>> Process::ProcessProcFSTraits::to_inode(const Pro
     return TRY(ProcFSProcessDirectoryInode::try_create(procfs_instance, process->pid()));
 }
 
-KResult Process::ProcessProcFSTraits::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> Process::ProcessProcFSTraits::traverse_as_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     auto process = m_process.strong_ref();
     if (!process)
@@ -62,7 +62,7 @@ KResult Process::ProcessProcFSTraits::traverse_as_directory(unsigned fsid, Funct
     callback({ "cwd", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::CurrentWorkDirectoryLink) }, DT_LNK });
     callback({ "perf_events", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::PerformanceEvents) }, DT_REG });
     callback({ "vm", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(process->pid(), SegmentedProcFSIndex::MainProcessProperty::VirtualMemoryStats) }, DT_REG });
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/ProcessSpecificExposed.cpp b/Kernel/ProcessSpecificExposed.cpp
index f18c46ec709..2c3a27b8d6d 100644
--- a/Kernel/ProcessSpecificExposed.cpp
+++ b/Kernel/ProcessSpecificExposed.cpp
@@ -18,12 +18,12 @@
 
 namespace Kernel {
 
-KResultOr<size_t> Process::procfs_get_thread_stack(ThreadID thread_id, KBufferBuilder& builder) const
+ErrorOr<size_t> Process::procfs_get_thread_stack(ThreadID thread_id, KBufferBuilder& builder) const
 {
     JsonArraySerializer array { builder };
     auto thread = Thread::from_tid(thread_id);
     if (!thread)
-        return KResult(ESRCH);
+        return Error::from_errno(ESRCH);
     bool show_kernel_addresses = Process::current().is_superuser();
     bool kernel_address_added = false;
     for (auto address : Processor::capture_stack_trace(*thread, 1024)) {
@@ -37,10 +37,11 @@ KResultOr<size_t> Process::procfs_get_thread_stack(ThreadID thread_id, KBufferBu
     }
 
     array.finish();
-    return KSuccess;
+    // FIXME: This return value seems useless.
+    return 0;
 }
 
-KResult Process::traverse_stacks_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> Process::traverse_stacks_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     callback({ ".", { fsid, SegmentedProcFSIndex::build_segmented_index_for_main_property(pid(), SegmentedProcFSIndex::ProcessSubDirectory::Stacks, SegmentedProcFSIndex::MainProcessProperty::Reserved) }, 0 });
     callback({ "..", { fsid, m_procfs_traits->component_index() }, 0 });
@@ -50,12 +51,12 @@ KResult Process::traverse_stacks_directory(unsigned fsid, Function<bool(FileSyst
         InodeIdentifier identifier = { fsid, SegmentedProcFSIndex::build_segmented_index_for_thread_stack(pid(), thread.tid()) };
         callback({ String::number(tid), identifier, 0 });
     });
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> Process::lookup_stacks_directory(const ProcFS& procfs, StringView name) const
+ErrorOr<NonnullRefPtr<Inode>> Process::lookup_stacks_directory(const ProcFS& procfs, StringView name) const
 {
-    KResultOr<NonnullRefPtr<ProcFSProcessPropertyInode>> thread_stack_inode { ENOENT };
+    ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> thread_stack_inode { ENOENT };
 
     // FIXME: Try to exit the loop earlier
     for_each_thread([&](const Thread& thread) {
@@ -64,7 +65,7 @@ KResultOr<NonnullRefPtr<Inode>> Process::lookup_stacks_directory(const ProcFS& p
         if (name.to_int() == tid) {
             auto maybe_inode = ProcFSProcessPropertyInode::try_create_for_thread_stack(procfs, thread.tid(), pid());
             if (maybe_inode.is_error()) {
-                thread_stack_inode = maybe_inode.error();
+                thread_stack_inode = maybe_inode.release_error();
                 return;
             }
 
@@ -73,11 +74,11 @@ KResultOr<NonnullRefPtr<Inode>> Process::lookup_stacks_directory(const ProcFS& p
     });
 
     if (thread_stack_inode.is_error())
-        return thread_stack_inode.error();
+        return thread_stack_inode.release_error();
     return thread_stack_inode.release_value();
 }
 
-KResultOr<size_t> Process::procfs_get_file_description_link(unsigned fd, KBufferBuilder& builder) const
+ErrorOr<size_t> Process::procfs_get_file_description_link(unsigned fd, KBufferBuilder& builder) const
 {
     auto file_description = TRY(m_fds.open_file_description(fd));
     // Note: These links are not guaranteed to point to actual VFS paths, just like in other kernels.
@@ -86,7 +87,7 @@ KResultOr<size_t> Process::procfs_get_file_description_link(unsigned fd, KBuffer
     return data->length();
 }
 
-KResult Process::traverse_file_descriptions_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
+ErrorOr<void> Process::traverse_file_descriptions_directory(unsigned fsid, Function<bool(FileSystem::DirectoryEntryView const&)> callback) const
 {
     callback({ ".", { fsid, m_procfs_traits->component_index() }, 0 });
     callback({ "..", { fsid, m_procfs_traits->component_index() }, 0 });
@@ -101,10 +102,10 @@ KResult Process::traverse_file_descriptions_directory(unsigned fsid, Function<bo
         callback({ builder.string_view(), { fsid, SegmentedProcFSIndex::build_segmented_index_for_file_description(pid(), count) }, DT_LNK });
         count++;
     });
-    return KSuccess;
+    return {};
 }
 
-KResultOr<NonnullRefPtr<Inode>> Process::lookup_file_descriptions_directory(const ProcFS& procfs, StringView name) const
+ErrorOr<NonnullRefPtr<Inode>> Process::lookup_file_descriptions_directory(const ProcFS& procfs, StringView name) const
 {
     auto maybe_index = name.to_uint();
     if (!maybe_index.has_value())
@@ -116,7 +117,7 @@ KResultOr<NonnullRefPtr<Inode>> Process::lookup_file_descriptions_directory(cons
     return TRY(ProcFSProcessPropertyInode::try_create_for_file_description_link(procfs, *maybe_index, pid()));
 }
 
-KResult Process::procfs_get_pledge_stats(KBufferBuilder& builder) const
+ErrorOr<void> Process::procfs_get_pledge_stats(KBufferBuilder& builder) const
 {
     JsonObjectSerializer obj { builder };
 #define __ENUMERATE_PLEDGE_PROMISE(x) \
@@ -132,10 +133,10 @@ KResult Process::procfs_get_pledge_stats(KBufferBuilder& builder) const
     }
 #undef __ENUMERATE_PLEDGE_PROMISE
     obj.finish();
-    return KSuccess;
+    return {};
 }
 
-KResult Process::procfs_get_unveil_stats(KBufferBuilder& builder) const
+ErrorOr<void> Process::procfs_get_unveil_stats(KBufferBuilder& builder) const
 {
     JsonArraySerializer array { builder };
     for (auto& unveiled_path : unveiled_paths()) {
@@ -157,25 +158,25 @@ KResult Process::procfs_get_unveil_stats(KBufferBuilder& builder) const
         obj.add("permissions", permissions_builder.to_string());
     }
     array.finish();
-    return KSuccess;
+    return {};
 }
 
-KResult Process::procfs_get_perf_events(KBufferBuilder& builder) const
+ErrorOr<void> Process::procfs_get_perf_events(KBufferBuilder& builder) const
 {
     InterruptDisabler disabler;
     if (!perf_events()) {
         dbgln("ProcFS: No perf events for {}", pid());
-        return KResult(ENOBUFS);
+        return Error::from_errno(ENOBUFS);
     }
     return perf_events()->to_json(builder);
 }
 
-KResult Process::procfs_get_fds_stats(KBufferBuilder& builder) const
+ErrorOr<void> Process::procfs_get_fds_stats(KBufferBuilder& builder) const
 {
     JsonArraySerializer array { builder };
     if (fds().open_count() == 0) {
         array.finish();
-        return KSuccess;
+        return {};
     }
 
     size_t count = 0;
@@ -209,10 +210,10 @@ KResult Process::procfs_get_fds_stats(KBufferBuilder& builder) const
     });
 
     array.finish();
-    return KSuccess;
+    return {};
 }
 
-KResult Process::procfs_get_virtual_memory_stats(KBufferBuilder& builder) const
+ErrorOr<void> Process::procfs_get_virtual_memory_stats(KBufferBuilder& builder) const
 {
     JsonArraySerializer array { builder };
     {
@@ -254,10 +255,10 @@ KResult Process::procfs_get_virtual_memory_stats(KBufferBuilder& builder) const
         }
     }
     array.finish();
-    return KSuccess;
+    return {};
 }
 
-KResult Process::procfs_get_current_work_directory_link(KBufferBuilder& builder) const
+ErrorOr<void> Process::procfs_get_current_work_directory_link(KBufferBuilder& builder) const
 {
     return builder.append_bytes(const_cast<Process&>(*this).current_directory().absolute_path().bytes());
 }
@@ -269,11 +270,11 @@ mode_t Process::binary_link_required_mode() const
     return m_procfs_traits->required_mode();
 }
 
-KResult Process::procfs_get_binary_link(KBufferBuilder& builder) const
+ErrorOr<void> Process::procfs_get_binary_link(KBufferBuilder& builder) const
 {
     auto* custody = executable();
     if (!custody)
-        return KResult(ENOEXEC);
+        return Error::from_errno(ENOEXEC);
     return builder.append(custody->absolute_path().bytes());
 }
 
diff --git a/Kernel/StdLib.cpp b/Kernel/StdLib.cpp
index 145f03d1b71..5c7c915bd9f 100644
--- a/Kernel/StdLib.cpp
+++ b/Kernel/StdLib.cpp
@@ -13,7 +13,7 @@
 #include <Kernel/Memory/MemoryManager.h>
 #include <Kernel/StdLib.h>
 
-Kernel::KResultOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Userspace<const char*> user_str, size_t user_str_size)
+ErrorOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Userspace<const char*> user_str, size_t user_str_size)
 {
     bool is_user = Kernel::Memory::is_user_range(VirtualAddress(user_str), user_str_size);
     if (!is_user)
@@ -40,14 +40,14 @@ Kernel::KResultOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Use
     return new_string;
 }
 
-KResultOr<Time> copy_time_from_user(timespec const* ts_user)
+ErrorOr<Time> copy_time_from_user(timespec const* ts_user)
 {
     timespec ts {};
     TRY(copy_from_user(&ts, ts_user, sizeof(timespec)));
     return Time::from_timespec(ts);
 }
 
-KResultOr<Time> copy_time_from_user(timeval const* tv_user)
+ErrorOr<Time> copy_time_from_user(timeval const* tv_user)
 {
     timeval tv {};
     TRY(copy_from_user(&tv, tv_user, sizeof(timeval)));
@@ -55,13 +55,13 @@ KResultOr<Time> copy_time_from_user(timeval const* tv_user)
 }
 
 template<>
-KResultOr<Time> copy_time_from_user<const timeval>(Userspace<timeval const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Time> copy_time_from_user<const timeval>(Userspace<timeval const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 template<>
-KResultOr<Time> copy_time_from_user<timeval>(Userspace<timeval*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Time> copy_time_from_user<timeval>(Userspace<timeval*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 template<>
-KResultOr<Time> copy_time_from_user<const timespec>(Userspace<timespec const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Time> copy_time_from_user<const timespec>(Userspace<timespec const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 template<>
-KResultOr<Time> copy_time_from_user<timespec>(Userspace<timespec*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Time> copy_time_from_user<timespec>(Userspace<timespec*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 
 Optional<u32> user_atomic_fetch_add_relaxed(volatile u32* var, u32 val)
 {
@@ -163,7 +163,7 @@ Optional<u32> user_atomic_fetch_xor_relaxed(volatile u32* var, u32 val)
     return Kernel::safe_atomic_fetch_xor_relaxed(var, val);
 }
 
-KResult copy_to_user(void* dest_ptr, void const* src_ptr, size_t n)
+ErrorOr<void> copy_to_user(void* dest_ptr, void const* src_ptr, size_t n)
 {
     if (!Kernel::Memory::is_user_range(VirtualAddress(dest_ptr), n))
         return EFAULT;
@@ -175,10 +175,10 @@ KResult copy_to_user(void* dest_ptr, void const* src_ptr, size_t n)
         dbgln("copy_to_user({:p}, {:p}, {}) failed at {}", dest_ptr, src_ptr, n, VirtualAddress { fault_at });
         return EFAULT;
     }
-    return KSuccess;
+    return {};
 }
 
-KResult copy_from_user(void* dest_ptr, void const* src_ptr, size_t n)
+ErrorOr<void> copy_from_user(void* dest_ptr, void const* src_ptr, size_t n)
 {
     if (!Kernel::Memory::is_user_range(VirtualAddress(src_ptr), n))
         return EFAULT;
@@ -190,10 +190,10 @@ KResult copy_from_user(void* dest_ptr, void const* src_ptr, size_t n)
         dbgln("copy_from_user({:p}, {:p}, {}) failed at {}", dest_ptr, src_ptr, n, VirtualAddress { fault_at });
         return EFAULT;
     }
-    return KSuccess;
+    return {};
 }
 
-KResult memset_user(void* dest_ptr, int c, size_t n)
+ErrorOr<void> memset_user(void* dest_ptr, int c, size_t n)
 {
     bool is_user = Kernel::Memory::is_user_range(VirtualAddress(dest_ptr), n);
     if (!is_user)
@@ -204,7 +204,7 @@ KResult memset_user(void* dest_ptr, int c, size_t n)
         dbgln("memset_user({:p}, {}, {}) failed at {}", dest_ptr, c, n, VirtualAddress { fault_at });
         return EFAULT;
     }
-    return KSuccess;
+    return {};
 }
 
 #if defined(__clang__) && defined(ENABLE_KERNEL_LTO)
diff --git a/Kernel/StdLib.h b/Kernel/StdLib.h
index a2e1bbbb476..ace6221c8bd 100644
--- a/Kernel/StdLib.h
+++ b/Kernel/StdLib.h
@@ -7,10 +7,10 @@
 #pragma once
 
 #include <AK/Checked.h>
+#include <AK/Error.h>
 #include <AK/Forward.h>
 #include <AK/Time.h>
 #include <AK/Userspace.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/KString.h>
 #include <Kernel/UnixTypes.h>
 
@@ -18,11 +18,11 @@ namespace Syscall {
 struct StringArgument;
 }
 
-[[nodiscard]] Kernel::KResultOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Userspace<const char*>, size_t);
-KResultOr<Time> copy_time_from_user(timespec const*);
-KResultOr<Time> copy_time_from_user(timeval const*);
+ErrorOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Userspace<const char*>, size_t);
+ErrorOr<Time> copy_time_from_user(timespec const*);
+ErrorOr<Time> copy_time_from_user(timeval const*);
 template<typename T>
-KResultOr<Time> copy_time_from_user(Userspace<T*>);
+ErrorOr<Time> copy_time_from_user(Userspace<T*>);
 
 [[nodiscard]] Optional<u32> user_atomic_fetch_add_relaxed(volatile u32* var, u32 val);
 [[nodiscard]] Optional<u32> user_atomic_exchange_relaxed(volatile u32* var, u32 val);
@@ -34,9 +34,9 @@ KResultOr<Time> copy_time_from_user(Userspace<T*>);
 [[nodiscard]] Optional<u32> user_atomic_fetch_or_relaxed(volatile u32* var, u32 val);
 [[nodiscard]] Optional<u32> user_atomic_fetch_xor_relaxed(volatile u32* var, u32 val);
 
-KResult copy_to_user(void*, const void*, size_t);
-KResult copy_from_user(void*, const void*, size_t);
-KResult memset_user(void*, int, size_t);
+ErrorOr<void> copy_to_user(void*, const void*, size_t);
+ErrorOr<void> copy_from_user(void*, const void*, size_t);
+ErrorOr<void> memset_user(void*, int, size_t);
 
 extern "C" {
 
@@ -56,76 +56,76 @@ const void* memmem(const void* haystack, size_t, const void* needle, size_t);
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_from_user(T* dest, const T* src)
+[[nodiscard]] inline ErrorOr<void> copy_from_user(T* dest, const T* src)
 {
     static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src, sizeof(T));
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_to_user(T* dest, const T* src)
+[[nodiscard]] inline ErrorOr<void> copy_to_user(T* dest, const T* src)
 {
     static_assert(IsTriviallyCopyable<T>);
     return copy_to_user(dest, src, sizeof(T));
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_from_user(T* dest, Userspace<const T*> src)
+[[nodiscard]] inline ErrorOr<void> copy_from_user(T* dest, Userspace<const T*> src)
 {
     static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src.unsafe_userspace_ptr(), sizeof(T));
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_from_user(T* dest, Userspace<T*> src)
+[[nodiscard]] inline ErrorOr<void> copy_from_user(T* dest, Userspace<T*> src)
 {
     static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src.unsafe_userspace_ptr(), sizeof(T));
 }
 
-#define DEPRECATE_COPY_FROM_USER_TYPE(T, REPLACEMENT)                                                                                   \
-    template<>                                                                                                                          \
-    [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) KResult copy_from_user<T>(T*, const T*)            \
-    {                                                                                                                                   \
-        VERIFY_NOT_REACHED();                                                                                                           \
-    }                                                                                                                                   \
-    template<>                                                                                                                          \
-    [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) KResult copy_from_user<T>(T*, Userspace<const T*>) \
-    {                                                                                                                                   \
-        VERIFY_NOT_REACHED();                                                                                                           \
-    }                                                                                                                                   \
-    template<>                                                                                                                          \
-    [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) KResult copy_from_user<T>(T*, Userspace<T*>)       \
-    {                                                                                                                                   \
-        VERIFY_NOT_REACHED();                                                                                                           \
+#define DEPRECATE_COPY_FROM_USER_TYPE(T, REPLACEMENT)                                                                                         \
+    template<>                                                                                                                                \
+    [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) ErrorOr<void> copy_from_user<T>(T*, const T*)            \
+    {                                                                                                                                         \
+        VERIFY_NOT_REACHED();                                                                                                                 \
+    }                                                                                                                                         \
+    template<>                                                                                                                                \
+    [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) ErrorOr<void> copy_from_user<T>(T*, Userspace<const T*>) \
+    {                                                                                                                                         \
+        VERIFY_NOT_REACHED();                                                                                                                 \
+    }                                                                                                                                         \
+    template<>                                                                                                                                \
+    [[nodiscard]] inline __attribute__((deprecated("use " #REPLACEMENT " instead"))) ErrorOr<void> copy_from_user<T>(T*, Userspace<T*>)       \
+    {                                                                                                                                         \
+        VERIFY_NOT_REACHED();                                                                                                                 \
     }
 
 DEPRECATE_COPY_FROM_USER_TYPE(timespec, copy_time_from_user)
 DEPRECATE_COPY_FROM_USER_TYPE(timeval, copy_time_from_user)
 
 template<typename T>
-[[nodiscard]] inline KResult copy_to_user(Userspace<T*> dest, const T* src)
+[[nodiscard]] inline ErrorOr<void> copy_to_user(Userspace<T*> dest, const T* src)
 {
     static_assert(IsTriviallyCopyable<T>);
     return copy_to_user(dest.unsafe_userspace_ptr(), src, sizeof(T));
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_to_user(Userspace<T*> dest, const void* src, size_t size)
+[[nodiscard]] inline ErrorOr<void> copy_to_user(Userspace<T*> dest, const void* src, size_t size)
 {
     static_assert(IsTriviallyCopyable<T>);
     return copy_to_user(dest.unsafe_userspace_ptr(), src, size);
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_from_user(void* dest, Userspace<const T*> src, size_t size)
+[[nodiscard]] inline ErrorOr<void> copy_from_user(void* dest, Userspace<const T*> src, size_t size)
 {
     static_assert(IsTriviallyCopyable<T>);
     return copy_from_user(dest, src.unsafe_userspace_ptr(), size);
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_n_from_user(T* dest, const T* src, size_t count)
+[[nodiscard]] inline ErrorOr<void> copy_n_from_user(T* dest, const T* src, size_t count)
 {
     static_assert(IsTriviallyCopyable<T>);
     Checked<size_t> size = sizeof(T);
@@ -136,7 +136,7 @@ template<typename T>
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_n_to_user(T* dest, const T* src, size_t count)
+[[nodiscard]] inline ErrorOr<void> copy_n_to_user(T* dest, const T* src, size_t count)
 {
     static_assert(IsTriviallyCopyable<T>);
     Checked<size_t> size = sizeof(T);
@@ -147,7 +147,7 @@ template<typename T>
 }
 
 template<typename T>
-[[nodiscard]] inline KResult copy_n_from_user(T* dest, Userspace<const T*> src, size_t count)
+[[nodiscard]] inline ErrorOr<void> copy_n_from_user(T* dest, Userspace<const T*> src, size_t count)
 {
     static_assert(IsTriviallyCopyable<T>);
     Checked<size_t> size = sizeof(T);
@@ -158,7 +158,7 @@ template<typename T>
 }
 
 template<typename T>
-[[nodiscard]] inline KResult try_copy_n_to_user(Userspace<T*> dest, const T* src, size_t count)
+[[nodiscard]] inline ErrorOr<void> try_copy_n_to_user(Userspace<T*> dest, const T* src, size_t count)
 {
     static_assert(IsTriviallyCopyable<T>);
     Checked<size_t> size = sizeof(T);
@@ -169,7 +169,7 @@ template<typename T>
 }
 
 template<typename T>
-inline KResultOr<T> copy_typed_from_user(Userspace<T const*> user_data)
+inline ErrorOr<T> copy_typed_from_user(Userspace<T const*> user_data)
 {
     T data {};
     TRY(copy_from_user(&data, user_data));
diff --git a/Kernel/Storage/Partition/DiskPartition.cpp b/Kernel/Storage/Partition/DiskPartition.cpp
index 265d5eb76ac..2e81fc99148 100644
--- a/Kernel/Storage/Partition/DiskPartition.cpp
+++ b/Kernel/Storage/Partition/DiskPartition.cpp
@@ -47,7 +47,7 @@ void DiskPartition::start_request(AsyncBlockDeviceRequest& request)
     request.add_sub_request(sub_request_or_error.release_value());
 }
 
-KResultOr<size_t> DiskPartition::read(OpenFileDescription& fd, u64 offset, UserOrKernelBuffer& outbuf, size_t len)
+ErrorOr<size_t> DiskPartition::read(OpenFileDescription& fd, u64 offset, UserOrKernelBuffer& outbuf, size_t len)
 {
     unsigned adjust = m_metadata.start_block() * block_size();
     dbgln_if(OFFD_DEBUG, "DiskPartition::read offset={}, adjust={}, len={}", fd.offset(), adjust, len);
@@ -61,7 +61,7 @@ bool DiskPartition::can_read(const OpenFileDescription& fd, size_t offset) const
     return m_device.strong_ref()->can_read(fd, offset + adjust);
 }
 
-KResultOr<size_t> DiskPartition::write(OpenFileDescription& fd, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
+ErrorOr<size_t> DiskPartition::write(OpenFileDescription& fd, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
 {
     unsigned adjust = m_metadata.start_block() * block_size();
     dbgln_if(OFFD_DEBUG, "DiskPartition::write offset={}, adjust={}, len={}", offset, adjust, len);
diff --git a/Kernel/Storage/Partition/DiskPartition.h b/Kernel/Storage/Partition/DiskPartition.h
index 4c172785bed..8c3e1ec6c16 100644
--- a/Kernel/Storage/Partition/DiskPartition.h
+++ b/Kernel/Storage/Partition/DiskPartition.h
@@ -23,9 +23,9 @@ public:
     virtual void start_request(AsyncBlockDeviceRequest&) override;
 
     // ^BlockDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
 
     const DiskPartitionMetadata& metadata() const;
diff --git a/Kernel/Storage/RamdiskDevice.cpp b/Kernel/Storage/RamdiskDevice.cpp
index 9a6c5103820..6d5a6ebd4fe 100644
--- a/Kernel/Storage/RamdiskDevice.cpp
+++ b/Kernel/Storage/RamdiskDevice.cpp
@@ -55,13 +55,13 @@ void RamdiskDevice::start_request(AsyncBlockDeviceRequest& request)
     if ((offset + length > base + size) || (offset + length < base)) {
         request.complete(AsyncDeviceRequest::Failure);
     } else {
-        auto result = KResult(KSuccess);
+        ErrorOr<void> result;
         if (request.request_type() == AsyncBlockDeviceRequest::Read) {
             result = request.buffer().write(offset, length);
         } else {
             result = request.buffer().read(offset, length);
         }
-        request.complete(result.is_success() ? AsyncDeviceRequest::Success : AsyncDeviceRequest::MemoryFault);
+        request.complete(!result.is_error() ? AsyncDeviceRequest::Success : AsyncDeviceRequest::MemoryFault);
     }
 }
 
diff --git a/Kernel/Storage/StorageDevice.cpp b/Kernel/Storage/StorageDevice.cpp
index 81020f01b56..1310d57f3ff 100644
--- a/Kernel/Storage/StorageDevice.cpp
+++ b/Kernel/Storage/StorageDevice.cpp
@@ -26,7 +26,7 @@ StringView StorageDevice::class_name() const
     return "StorageDevice"sv;
 }
 
-KResultOr<size_t> StorageDevice::read(OpenFileDescription&, u64 offset, UserOrKernelBuffer& outbuf, size_t len)
+ErrorOr<size_t> StorageDevice::read(OpenFileDescription&, u64 offset, UserOrKernelBuffer& outbuf, size_t len)
 {
     unsigned index = offset / block_size();
     u16 whole_blocks = len / block_size();
@@ -93,7 +93,7 @@ bool StorageDevice::can_read(const OpenFileDescription&, size_t offset) const
     return offset < (max_addressable_block() * block_size());
 }
 
-KResultOr<size_t> StorageDevice::write(OpenFileDescription&, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
+ErrorOr<size_t> StorageDevice::write(OpenFileDescription&, u64 offset, const UserOrKernelBuffer& inbuf, size_t len)
 {
     unsigned index = offset / block_size();
     u16 whole_blocks = len / block_size();
@@ -188,7 +188,7 @@ bool StorageDevice::can_write(const OpenFileDescription&, size_t offset) const
     return offset < (max_addressable_block() * block_size());
 }
 
-KResult StorageDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
+ErrorOr<void> StorageDevice::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     switch (request) {
     case STORAGE_DEVICE_GET_SIZE: {
diff --git a/Kernel/Storage/StorageDevice.h b/Kernel/Storage/StorageDevice.h
index 86b1b38d488..eda12161976 100644
--- a/Kernel/Storage/StorageDevice.h
+++ b/Kernel/Storage/StorageDevice.h
@@ -37,9 +37,9 @@ public:
     virtual u64 max_addressable_block() const { return m_max_addressable_block; }
 
     // ^BlockDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
     virtual void prepare_for_unplug() { m_partitions.clear(); }
 
@@ -51,7 +51,7 @@ public:
     virtual CommandSet command_set() const = 0;
 
     // ^File
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) final;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) final;
 
 protected:
     StorageDevice(int, int, size_t, u64, NonnullOwnPtr<KString>);
diff --git a/Kernel/Storage/StorageManagement.cpp b/Kernel/Storage/StorageManagement.cpp
index cb0d9d237aa..9c1b6035a8a 100644
--- a/Kernel/Storage/StorageManagement.cpp
+++ b/Kernel/Storage/StorageManagement.cpp
@@ -187,7 +187,7 @@ NonnullRefPtr<FileSystem> StorageManagement::root_filesystem() const
     auto file_system = Ext2FS::try_create(description_or_error.release_value()).release_value();
 
     if (auto result = file_system->initialize(); result.is_error()) {
-        PANIC("StorageManagement: Couldn't open root filesystem: {}", result);
+        PANIC("StorageManagement: Couldn't open root filesystem: {}", result.error());
     }
     return file_system;
 }
diff --git a/Kernel/Syscall.cpp b/Kernel/Syscall.cpp
index c8eb76ba602..1675902433a 100644
--- a/Kernel/Syscall.cpp
+++ b/Kernel/Syscall.cpp
@@ -81,15 +81,15 @@ NEVER_INLINE NAKED void syscall_asm_entry()
 
 namespace Syscall {
 
-static KResultOr<FlatPtr> handle(RegisterState&, FlatPtr function, FlatPtr arg1, FlatPtr arg2, FlatPtr arg3, FlatPtr arg4);
+static ErrorOr<FlatPtr> handle(RegisterState&, FlatPtr function, FlatPtr arg1, FlatPtr arg2, FlatPtr arg3, FlatPtr arg4);
 
 UNMAP_AFTER_INIT void initialize()
 {
     register_user_callable_interrupt_handler(syscall_vector, syscall_asm_entry);
 }
 
-using Handler = auto (Process::*)(FlatPtr, FlatPtr, FlatPtr, FlatPtr) -> KResultOr<FlatPtr>;
-using HandlerWithRegisterState = auto (Process::*)(RegisterState&) -> KResultOr<FlatPtr>;
+using Handler = auto (Process::*)(FlatPtr, FlatPtr, FlatPtr, FlatPtr) -> ErrorOr<FlatPtr>;
+using HandlerWithRegisterState = auto (Process::*)(RegisterState&) -> ErrorOr<FlatPtr>;
 
 struct HandlerMetadata {
     Handler handler;
@@ -102,7 +102,7 @@ static const HandlerMetadata s_syscall_table[] = {
 };
 #undef __ENUMERATE_SYSCALL
 
-KResultOr<FlatPtr> handle(RegisterState& regs, FlatPtr function, FlatPtr arg1, FlatPtr arg2, FlatPtr arg3, FlatPtr arg4)
+ErrorOr<FlatPtr> handle(RegisterState& regs, FlatPtr function, FlatPtr arg1, FlatPtr arg2, FlatPtr arg3, FlatPtr arg4)
 {
     VERIFY_INTERRUPTS_ENABLED();
     auto current_thread = Thread::current();
@@ -148,7 +148,7 @@ KResultOr<FlatPtr> handle(RegisterState& regs, FlatPtr function, FlatPtr arg1, F
         }
     }
 
-    KResultOr<FlatPtr> result { FlatPtr(nullptr) };
+    ErrorOr<FlatPtr> result { FlatPtr(nullptr) };
     if (function == SC_fork || function == SC_sigreturn) {
         // These syscalls want the RegisterState& rather than individual parameters.
         auto handler = bit_cast<HandlerWithRegisterState>(syscall_metadata.handler);
@@ -214,7 +214,7 @@ NEVER_INLINE void syscall_handler(TrapFrame* trap)
     auto result = Syscall::handle(regs, function, arg1, arg2, arg3, arg4);
 
     if (result.is_error()) {
-        regs.set_return_reg(result.error().error());
+        regs.set_return_reg(-result.error().code());
     } else {
         regs.set_return_reg(result.value());
     }
diff --git a/Kernel/Syscalls/access.cpp b/Kernel/Syscalls/access.cpp
index 2e2c27d71c3..90000ed7cec 100644
--- a/Kernel/Syscalls/access.cpp
+++ b/Kernel/Syscalls/access.cpp
@@ -10,12 +10,13 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$access(Userspace<const char*> user_path, size_t path_length, int mode)
+ErrorOr<FlatPtr> Process::sys$access(Userspace<const char*> user_path, size_t path_length, int mode)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(rpath);
     auto path = TRY(get_syscall_path_argument(user_path, path_length));
-    return VirtualFileSystem::the().access(path->view(), mode, current_directory());
+    TRY(VirtualFileSystem::the().access(path->view(), mode, current_directory()));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/alarm.cpp b/Kernel/Syscalls/alarm.cpp
index 3ffb2d8f535..67dad0c1d41 100644
--- a/Kernel/Syscalls/alarm.cpp
+++ b/Kernel/Syscalls/alarm.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$alarm(unsigned seconds)
+ErrorOr<FlatPtr> Process::sys$alarm(unsigned seconds)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/anon_create.cpp b/Kernel/Syscalls/anon_create.cpp
index f25ae4b2bab..92a1b9a4484 100644
--- a/Kernel/Syscalls/anon_create.cpp
+++ b/Kernel/Syscalls/anon_create.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$anon_create(size_t size, int options)
+ErrorOr<FlatPtr> Process::sys$anon_create(size_t size, int options)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/beep.cpp b/Kernel/Syscalls/beep.cpp
index 0fc0ea7cb76..3e2453107fb 100644
--- a/Kernel/Syscalls/beep.cpp
+++ b/Kernel/Syscalls/beep.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$beep()
+ErrorOr<FlatPtr> Process::sys$beep()
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     PCSpeaker::tone_on(440);
diff --git a/Kernel/Syscalls/chdir.cpp b/Kernel/Syscalls/chdir.cpp
index 2af24a3565b..9cecaae6c05 100644
--- a/Kernel/Syscalls/chdir.cpp
+++ b/Kernel/Syscalls/chdir.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t path_length)
+ErrorOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t path_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(rpath);
@@ -19,7 +19,7 @@ KResultOr<FlatPtr> Process::sys$chdir(Userspace<const char*> user_path, size_t p
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$fchdir(int fd)
+ErrorOr<FlatPtr> Process::sys$fchdir(int fd)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
@@ -32,7 +32,7 @@ KResultOr<FlatPtr> Process::sys$fchdir(int fd)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$getcwd(Userspace<char*> buffer, size_t size)
+ErrorOr<FlatPtr> Process::sys$getcwd(Userspace<char*> buffer, size_t size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(rpath);
diff --git a/Kernel/Syscalls/chmod.cpp b/Kernel/Syscalls/chmod.cpp
index b66284fd590..aecd9ffb59b 100644
--- a/Kernel/Syscalls/chmod.cpp
+++ b/Kernel/Syscalls/chmod.cpp
@@ -10,20 +10,22 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$chmod(Userspace<const char*> user_path, size_t path_length, mode_t mode)
+ErrorOr<FlatPtr> Process::sys$chmod(Userspace<const char*> user_path, size_t path_length, mode_t mode)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(fattr);
     auto path = TRY(get_syscall_path_argument(user_path, path_length));
-    return VirtualFileSystem::the().chmod(path->view(), mode, current_directory());
+    TRY(VirtualFileSystem::the().chmod(path->view(), mode, current_directory()));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$fchmod(int fd, mode_t mode)
+ErrorOr<FlatPtr> Process::sys$fchmod(int fd, mode_t mode)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(fattr);
     auto description = TRY(fds().open_file_description(fd));
-    return description->chmod(mode);
+    TRY(description->chmod(mode));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/chown.cpp b/Kernel/Syscalls/chown.cpp
index 3e2fe6aaca5..7f7a5855382 100644
--- a/Kernel/Syscalls/chown.cpp
+++ b/Kernel/Syscalls/chown.cpp
@@ -9,22 +9,23 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$fchown(int fd, UserID uid, GroupID gid)
+ErrorOr<FlatPtr> Process::sys$fchown(int fd, UserID uid, GroupID gid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(chown);
     auto description = TRY(fds().open_file_description(fd));
-    return description->chown(uid, gid);
+    TRY(description->chown(uid, gid));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$chown(Userspace<const Syscall::SC_chown_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$chown(Userspace<const Syscall::SC_chown_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(chown);
     auto params = TRY(copy_typed_from_user(user_params));
-
     auto path = TRY(get_syscall_path_argument(params.path));
-    return VirtualFileSystem::the().chown(path->view(), params.uid, params.gid, current_directory());
+    TRY(VirtualFileSystem::the().chown(path->view(), params.uid, params.gid, current_directory()));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/clock.cpp b/Kernel/Syscalls/clock.cpp
index a6dae062c26..944935724c8 100644
--- a/Kernel/Syscalls/clock.cpp
+++ b/Kernel/Syscalls/clock.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$map_time_page()
+ErrorOr<FlatPtr> Process::sys$map_time_page()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
@@ -22,7 +22,7 @@ KResultOr<FlatPtr> Process::sys$map_time_page()
     return region->vaddr().get();
 }
 
-KResultOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<timespec*> user_ts)
+ErrorOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<timespec*> user_ts)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     REQUIRE_PROMISE(stdio);
@@ -31,10 +31,11 @@ KResultOr<FlatPtr> Process::sys$clock_gettime(clockid_t clock_id, Userspace<time
         return EINVAL;
 
     auto ts = TimeManagement::the().current_time(clock_id).to_timespec();
-    return copy_to_user(user_ts, &ts);
+    TRY(copy_to_user(user_ts, &ts));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<const timespec*> user_ts)
+ErrorOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<const timespec*> user_ts)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(settime);
@@ -54,7 +55,7 @@ KResultOr<FlatPtr> Process::sys$clock_settime(clockid_t clock_id, Userspace<cons
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_clock_nanosleep_params*> user_params)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     REQUIRE_PROMISE(stdio);
@@ -93,7 +94,7 @@ KResultOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<const Syscall::SC_cloc
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Userspace<timeval*> user_old_delta)
+ErrorOr<FlatPtr> Process::sys$adjtime(Userspace<const timeval*> user_delta, Userspace<timeval*> user_old_delta)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     if (user_old_delta) {
diff --git a/Kernel/Syscalls/debug.cpp b/Kernel/Syscalls/debug.cpp
index f5d65de3cd3..fc9a5f781ae 100644
--- a/Kernel/Syscalls/debug.cpp
+++ b/Kernel/Syscalls/debug.cpp
@@ -11,21 +11,21 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$dump_backtrace()
+ErrorOr<FlatPtr> Process::sys$dump_backtrace()
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     dump_backtrace();
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$dbgputch(u8 ch)
+ErrorOr<FlatPtr> Process::sys$dbgputch(u8 ch)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     dbgputch(ch);
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$dbgputstr(Userspace<const char*> characters, size_t size)
+ErrorOr<FlatPtr> Process::sys$dbgputstr(Userspace<const char*> characters, size_t size)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     if (size == 0)
diff --git a/Kernel/Syscalls/disown.cpp b/Kernel/Syscalls/disown.cpp
index 09ac972dc39..b18c139b5a5 100644
--- a/Kernel/Syscalls/disown.cpp
+++ b/Kernel/Syscalls/disown.cpp
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$disown(ProcessID pid)
+ErrorOr<FlatPtr> Process::sys$disown(ProcessID pid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(proc);
diff --git a/Kernel/Syscalls/dup2.cpp b/Kernel/Syscalls/dup2.cpp
index 22cd74123a4..ed0c8e74d0f 100644
--- a/Kernel/Syscalls/dup2.cpp
+++ b/Kernel/Syscalls/dup2.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$dup2(int old_fd, int new_fd)
+ErrorOr<FlatPtr> Process::sys$dup2(int old_fd, int new_fd)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/emuctl.cpp b/Kernel/Syscalls/emuctl.cpp
index eed49369103..cb447018978 100644
--- a/Kernel/Syscalls/emuctl.cpp
+++ b/Kernel/Syscalls/emuctl.cpp
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$emuctl()
+ErrorOr<FlatPtr> Process::sys$emuctl()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     return ENOSYS;
diff --git a/Kernel/Syscalls/execve.cpp b/Kernel/Syscalls/execve.cpp
index 32c81c896de..7889e032cd5 100644
--- a/Kernel/Syscalls/execve.cpp
+++ b/Kernel/Syscalls/execve.cpp
@@ -68,7 +68,7 @@ static bool validate_stack_size(NonnullOwnPtrVector<KString> const& arguments, N
     return true;
 }
 
-static KResultOr<FlatPtr> make_userspace_context_for_main_thread([[maybe_unused]] ThreadRegisters& regs, Memory::Region& region, NonnullOwnPtrVector<KString> const& arguments,
+static ErrorOr<FlatPtr> make_userspace_context_for_main_thread([[maybe_unused]] ThreadRegisters& regs, Memory::Region& region, NonnullOwnPtrVector<KString> const& arguments,
     NonnullOwnPtrVector<KString> const& environment, Vector<ELF::AuxiliaryValue> auxiliary_values)
 {
     FlatPtr new_sp = region.range().end().get();
@@ -80,21 +80,21 @@ static KResultOr<FlatPtr> make_userspace_context_for_main_thread([[maybe_unused]
         new_sp -= sizeof(FlatPtr);
         Userspace<FlatPtr*> stack_ptr = new_sp;
         auto result = copy_to_user(stack_ptr, &value);
-        VERIFY(result.is_success());
+        VERIFY(!result.is_error());
     };
 
     auto push_aux_value_on_new_stack = [&new_sp](auxv_t value) {
         new_sp -= sizeof(auxv_t);
         Userspace<auxv_t*> stack_ptr = new_sp;
         auto result = copy_to_user(stack_ptr, &value);
-        VERIFY(result.is_success());
+        VERIFY(!result.is_error());
     };
 
     auto push_string_on_new_stack = [&new_sp](StringView string) {
         new_sp -= round_up_to_power_of_two(string.length() + 1, sizeof(FlatPtr));
         Userspace<FlatPtr*> stack_ptr = new_sp;
         auto result = copy_to_user(stack_ptr, string.characters_without_null_termination(), string.length() + 1);
-        VERIFY(result.is_success());
+        VERIFY(!result.is_error());
     };
 
     Vector<FlatPtr> argv_entries;
@@ -162,7 +162,7 @@ struct RequiredLoadRange {
     FlatPtr end { 0 };
 };
 
-static KResultOr<RequiredLoadRange> get_required_load_range(OpenFileDescription& program_description)
+static ErrorOr<RequiredLoadRange> get_required_load_range(OpenFileDescription& program_description)
 {
     auto& inode = *(program_description.inode());
     auto vmobject = TRY(Memory::SharedInodeVMObject::try_create_with_inode(inode));
@@ -192,7 +192,7 @@ static KResultOr<RequiredLoadRange> get_required_load_range(OpenFileDescription&
     return range;
 };
 
-static KResultOr<FlatPtr> get_load_offset(const ElfW(Ehdr) & main_program_header, OpenFileDescription& main_program_description, OpenFileDescription* interpreter_description)
+static ErrorOr<FlatPtr> get_load_offset(const ElfW(Ehdr) & main_program_header, OpenFileDescription& main_program_description, OpenFileDescription* interpreter_description)
 {
     constexpr FlatPtr load_range_start = 0x08000000;
     constexpr FlatPtr load_range_size = 65536 * PAGE_SIZE; // 2**16 * PAGE_SIZE = 256MB
@@ -251,7 +251,7 @@ enum class ShouldAllowSyscalls {
     Yes,
 };
 
-static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace> new_space, OpenFileDescription& object_description,
+static ErrorOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace> new_space, OpenFileDescription& object_description,
     FlatPtr load_offset, ShouldAllocateTls should_allocate_tls, ShouldAllowSyscalls should_allow_syscalls)
 {
     auto& inode = *(object_description.inode());
@@ -280,7 +280,7 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
 
     Memory::MemoryManager::enter_address_space(*new_space);
 
-    auto load_tls_section = [&](auto& program_header) -> KResult {
+    auto load_tls_section = [&](auto& program_header) -> ErrorOr<void> {
         VERIFY(should_allocate_tls == ShouldAllocateTls::Yes);
         VERIFY(program_header.size_in_memory());
 
@@ -295,10 +295,10 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
         master_tls_alignment = program_header.alignment();
 
         TRY(copy_to_user(master_tls_region->vaddr().as_ptr(), program_header.raw_data(), program_header.size_in_image()));
-        return KSuccess;
+        return {};
     };
 
-    auto load_writable_section = [&](auto& program_header) -> KResult {
+    auto load_writable_section = [&](auto& program_header) -> ErrorOr<void> {
         // Writable section: create a copy in memory.
         VERIFY(program_header.alignment() == PAGE_SIZE);
 
@@ -330,12 +330,12 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
         auto page_offset = program_header.vaddr();
         page_offset.mask(~PAGE_MASK);
         TRY(copy_to_user((u8*)region->vaddr().as_ptr() + page_offset.get(), program_header.raw_data(), program_header.size_in_image()));
-        return KSuccess;
+        return {};
     };
 
-    auto load_section = [&](auto& program_header) -> KResult {
+    auto load_section = [&](auto& program_header) -> ErrorOr<void> {
         if (program_header.size_in_memory() == 0)
-            return KSuccess;
+            return {};
 
         if (program_header.is_writable())
             return load_writable_section(program_header);
@@ -359,10 +359,10 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
             region->set_syscall_region(true);
         if (program_header.offset() == 0)
             load_base_address = (FlatPtr)region->vaddr().as_ptr();
-        return KSuccess;
+        return {};
     };
 
-    auto load_elf_program_header = [&](auto& program_header) -> KResult {
+    auto load_elf_program_header = [&](auto& program_header) -> ErrorOr<void> {
         if (program_header.type() == PT_TLS)
             return load_tls_section(program_header);
 
@@ -370,11 +370,11 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
             return load_section(program_header);
 
         // NOTE: We ignore other program header types.
-        return KSuccess;
+        return {};
     };
 
     TRY([&] {
-        KResult result = KSuccess;
+        ErrorOr<void> result;
         elf_image.for_each_program_header([&](ELF::Image::ProgramHeader const& program_header) {
             result = load_elf_program_header(program_header);
             return result.is_error() ? IterationDecision::Break : IterationDecision::Continue;
@@ -403,7 +403,7 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Memory::AddressSpace>
     };
 }
 
-KResultOr<LoadResult>
+ErrorOr<LoadResult>
 Process::load(NonnullRefPtr<OpenFileDescription> main_program_description,
     RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header)
 {
@@ -433,7 +433,7 @@ Process::load(NonnullRefPtr<OpenFileDescription> main_program_description,
     return interpreter_load_result;
 }
 
-KResult Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment,
+ErrorOr<void> Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment,
     RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const ElfW(Ehdr) & main_program_header)
 {
     VERIFY(is_user_process());
@@ -555,10 +555,7 @@ KResult Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_descrip
 
     // NOTE: We create the new stack before disabling interrupts since it will zero-fault
     //       and we don't want to deal with faults after this point.
-    auto make_stack_result = make_userspace_context_for_main_thread(new_main_thread->regs(), *load_result.stack_region.unsafe_ptr(), m_arguments, m_environment, move(auxv));
-    if (make_stack_result.is_error())
-        return make_stack_result.error();
-    FlatPtr new_userspace_sp = make_stack_result.value();
+    auto new_userspace_sp = TRY(make_userspace_context_for_main_thread(new_main_thread->regs(), *load_result.stack_region.unsafe_ptr(), m_arguments, m_environment, move(auxv)));
 
     if (wait_for_tracer_at_next_execve()) {
         // Make sure we release the ptrace lock here or the tracer will block forever.
@@ -632,7 +629,7 @@ KResult Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_descrip
     [[maybe_unused]] auto rc = big_lock().force_unlock_if_locked(lock_count_to_restore);
     VERIFY_INTERRUPTS_DISABLED();
     VERIFY(Processor::in_critical());
-    return KSuccess;
+    return {};
 }
 
 static Vector<ELF::AuxiliaryValue> generate_auxiliary_vector(FlatPtr load_base, FlatPtr entry_eip, UserID uid, UserID euid, GroupID gid, GroupID egid, StringView executable_path, Optional<Process::ScopedDescriptionAllocation> const& main_program_fd_allocation)
@@ -673,7 +670,7 @@ static Vector<ELF::AuxiliaryValue> generate_auxiliary_vector(FlatPtr load_base,
     return auxv;
 }
 
-static KResultOr<NonnullOwnPtrVector<KString>> find_shebang_interpreter_for_executable(char const first_page[], size_t nread)
+static ErrorOr<NonnullOwnPtrVector<KString>> find_shebang_interpreter_for_executable(char const first_page[], size_t nread)
 {
     int word_start = 2;
     size_t word_length = 0;
@@ -711,9 +708,9 @@ static KResultOr<NonnullOwnPtrVector<KString>> find_shebang_interpreter_for_exec
     return ENOEXEC;
 }
 
-KResultOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size)
+ErrorOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size)
 {
-    // Not using KResultOr here because we'll want to do the same thing in userspace in the RTLD
+    // Not using ErrorOr here because we'll want to do the same thing in userspace in the RTLD
     String interpreter_path;
     if (!ELF::validate_program_headers(main_executable_header, file_size, (u8 const*)&main_executable_header, main_executable_header_size, &interpreter_path)) {
         dbgln("exec({}): File has invalid ELF Program headers", path);
@@ -745,7 +742,7 @@ KResultOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executa
             return ENOEXEC;
         }
 
-        // Not using KResultOr here because we'll want to do the same thing in userspace in the RTLD
+        // Not using ErrorOr here because we'll want to do the same thing in userspace in the RTLD
         String interpreter_interpreter_path;
         if (!ELF::validate_program_headers(*elf_header, interp_metadata.size, (u8*)first_page, nread, &interpreter_interpreter_path)) {
             dbgln("exec({}): Interpreter ({}) has invalid ELF Program headers", path, interpreter_path);
@@ -776,7 +773,7 @@ KResultOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executa
     return nullptr;
 }
 
-KResult Process::exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, int recursion_depth)
+ErrorOr<void> Process::exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString> arguments, NonnullOwnPtrVector<KString> environment, int recursion_depth)
 {
     if (recursion_depth > 2) {
         dbgln("exec({}): SHENANIGANS! recursed too far trying to find #! interpreter", path);
@@ -859,10 +856,10 @@ KResult Process::exec(NonnullOwnPtr<KString> path, NonnullOwnPtrVector<KString>
     if (prev_flags & 0x200)
         sti();
     Processor::leave_critical();
-    return KSuccess;
+    return {};
 }
 
-KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(exec);
@@ -876,9 +873,9 @@ KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params
 
     auto path = TRY(get_syscall_path_argument(params.path));
 
-    auto copy_user_strings = [](const auto& list, auto& output) -> KResult {
+    auto copy_user_strings = [](const auto& list, auto& output) -> ErrorOr<void> {
         if (!list.length)
-            return KSuccess;
+            return {};
         Checked<size_t> size = sizeof(*list.strings);
         size *= list.length;
         if (size.has_overflow())
@@ -892,7 +889,7 @@ KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params
             if (!output.try_append(move(string)))
                 return ENOMEM;
         }
-        return KSuccess;
+        return {};
     };
 
     NonnullOwnPtrVector<KString> arguments;
@@ -901,8 +898,9 @@ KResultOr<FlatPtr> Process::sys$execve(Userspace<const Syscall::SC_execve_params
     NonnullOwnPtrVector<KString> environment;
     TRY(copy_user_strings(params.environment, environment));
 
-    auto result = exec(move(path), move(arguments), move(environment));
-    VERIFY(result.is_error()); // We should never continue after a successful exec!
-    return result.error();
+    TRY(exec(move(path), move(arguments), move(environment)));
+    // We should never continue after a successful exec!
+    VERIFY_NOT_REACHED();
 }
+
 }
diff --git a/Kernel/Syscalls/fcntl.cpp b/Kernel/Syscalls/fcntl.cpp
index ed5da4e9750..ff1b2b208b4 100644
--- a/Kernel/Syscalls/fcntl.cpp
+++ b/Kernel/Syscalls/fcntl.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
+ErrorOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
@@ -40,9 +40,11 @@ KResultOr<FlatPtr> Process::sys$fcntl(int fd, int cmd, u32 arg)
     case F_ISTTY:
         return description->is_tty();
     case F_GETLK:
-        return description->get_flock(Userspace<flock*>(arg));
+        TRY(description->get_flock(Userspace<flock*>(arg)));
+        return 0;
     case F_SETLK:
-        return description->apply_flock(Process::current(), Userspace<const flock*>(arg));
+        TRY(description->apply_flock(Process::current(), Userspace<const flock*>(arg)));
+        return 0;
     default:
         return EINVAL;
     }
diff --git a/Kernel/Syscalls/fork.cpp b/Kernel/Syscalls/fork.cpp
index fec0778a5a5..d81910d46a2 100644
--- a/Kernel/Syscalls/fork.cpp
+++ b/Kernel/Syscalls/fork.cpp
@@ -13,7 +13,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$fork(RegisterState& regs)
+ErrorOr<FlatPtr> Process::sys$fork(RegisterState& regs)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(proc);
diff --git a/Kernel/Syscalls/fsync.cpp b/Kernel/Syscalls/fsync.cpp
index 3e1445de777..104f93f9d37 100644
--- a/Kernel/Syscalls/fsync.cpp
+++ b/Kernel/Syscalls/fsync.cpp
@@ -8,12 +8,13 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$fsync(int fd)
+ErrorOr<FlatPtr> Process::sys$fsync(int fd)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
     auto description = TRY(fds().open_file_description(fd));
-    return description->sync();
+    TRY(description->sync());
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/ftruncate.cpp b/Kernel/Syscalls/ftruncate.cpp
index 050da17410a..f430d254331 100644
--- a/Kernel/Syscalls/ftruncate.cpp
+++ b/Kernel/Syscalls/ftruncate.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_length)
+ErrorOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -20,7 +20,8 @@ KResultOr<FlatPtr> Process::sys$ftruncate(int fd, Userspace<off_t*> userspace_le
     auto description = TRY(fds().open_file_description(fd));
     if (!description->is_writable())
         return EBADF;
-    return description->truncate(static_cast<u64>(length));
+    TRY(description->truncate(static_cast<u64>(length)));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/futex.cpp b/Kernel/Syscalls/futex.cpp
index 2080c8d63f5..b03963a8826 100644
--- a/Kernel/Syscalls/futex.cpp
+++ b/Kernel/Syscalls/futex.cpp
@@ -22,7 +22,7 @@ void Process::clear_futex_queues_on_exec()
     m_futex_queues.clear();
 }
 
-KResultOr<FlatPtr> Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     auto params = TRY(copy_typed_from_user(user_params));
diff --git a/Kernel/Syscalls/get_dir_entries.cpp b/Kernel/Syscalls/get_dir_entries.cpp
index 49e0fba98e7..604ab58af19 100644
--- a/Kernel/Syscalls/get_dir_entries.cpp
+++ b/Kernel/Syscalls/get_dir_entries.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, size_t user_size)
+ErrorOr<FlatPtr> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, size_t user_size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(stdio);
@@ -19,11 +19,8 @@ KResultOr<FlatPtr> Process::sys$get_dir_entries(int fd, Userspace<void*> user_bu
     auto buffer = UserOrKernelBuffer::for_user_buffer(user_buffer, static_cast<size_t>(user_size));
     if (!buffer.has_value())
         return EFAULT;
-    auto result = description->get_dir_entries(buffer.value(), user_size);
-    if (result.is_error())
-        return result.error();
-    else
-        return result.release_value();
+    auto count = TRY(description->get_dir_entries(buffer.value(), user_size));
+    return count;
 }
 
 }
diff --git a/Kernel/Syscalls/get_stack_bounds.cpp b/Kernel/Syscalls/get_stack_bounds.cpp
index 5def4749568..1c77277b47d 100644
--- a/Kernel/Syscalls/get_stack_bounds.cpp
+++ b/Kernel/Syscalls/get_stack_bounds.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_base, Userspace<size_t*> user_stack_size)
+ErrorOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_base, Userspace<size_t*> user_stack_size)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     auto& regs = Thread::current()->get_register_dump_from_stack();
@@ -22,7 +22,8 @@ KResultOr<FlatPtr> Process::sys$get_stack_bounds(Userspace<FlatPtr*> user_stack_
     FlatPtr stack_base = stack_region->range().base().get();
     size_t stack_size = stack_region->size();
     TRY(copy_to_user(user_stack_base, &stack_base));
-    return copy_to_user(user_stack_size, &stack_size);
+    TRY(copy_to_user(user_stack_size, &stack_size));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/getrandom.cpp b/Kernel/Syscalls/getrandom.cpp
index 5322dafdf3a..21e9efb848d 100644
--- a/Kernel/Syscalls/getrandom.cpp
+++ b/Kernel/Syscalls/getrandom.cpp
@@ -13,7 +13,7 @@ namespace Kernel {
 // We don't use the flag yet, but we could use it for distinguishing
 // random source like Linux, unlike the OpenBSD equivalent. However, if we
 // do, we should be able of the caveats that Linux has dealt with.
-KResultOr<FlatPtr> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
+ErrorOr<FlatPtr> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/getuid.cpp b/Kernel/Syscalls/getuid.cpp
index 5185fa60dfd..da3cc535f9d 100644
--- a/Kernel/Syscalls/getuid.cpp
+++ b/Kernel/Syscalls/getuid.cpp
@@ -8,55 +8,55 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$getuid()
+ErrorOr<FlatPtr> Process::sys$getuid()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     return uid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$getgid()
+ErrorOr<FlatPtr> Process::sys$getgid()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     return gid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$geteuid()
+ErrorOr<FlatPtr> Process::sys$geteuid()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     return euid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$getegid()
+ErrorOr<FlatPtr> Process::sys$getegid()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     return egid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$getresuid(Userspace<UserID*> ruid, Userspace<UserID*> euid, Userspace<UserID*> suid)
+ErrorOr<FlatPtr> Process::sys$getresuid(Userspace<UserID*> ruid, Userspace<UserID*> euid, Userspace<UserID*> suid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     TRY(copy_to_user(ruid, &m_protected_values.uid));
     TRY(copy_to_user(euid, &m_protected_values.euid));
     TRY(copy_to_user(suid, &m_protected_values.suid));
-    return KSuccess;
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$getresgid(Userspace<GroupID*> rgid, Userspace<GroupID*> egid, Userspace<GroupID*> sgid)
+ErrorOr<FlatPtr> Process::sys$getresgid(Userspace<GroupID*> rgid, Userspace<GroupID*> egid, Userspace<GroupID*> sgid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     TRY(copy_to_user(rgid, &m_protected_values.gid));
     TRY(copy_to_user(egid, &m_protected_values.egid));
     TRY(copy_to_user(sgid, &m_protected_values.sgid));
-    return KSuccess;
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids)
+ErrorOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -64,7 +64,8 @@ KResultOr<FlatPtr> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_g
         return extra_gids().size();
     if (count != extra_gids().size())
         return EINVAL;
-    return copy_to_user(user_gids, extra_gids().data(), sizeof(gid_t) * count);
+    TRY(copy_to_user(user_gids, extra_gids().data(), sizeof(gid_t) * count));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/hostname.cpp b/Kernel/Syscalls/hostname.cpp
index 7dd259522a0..4529966d100 100644
--- a/Kernel/Syscalls/hostname.cpp
+++ b/Kernel/Syscalls/hostname.cpp
@@ -8,13 +8,13 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
+ErrorOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this)
     REQUIRE_PROMISE(stdio);
     if (size > NumericLimits<ssize_t>::max())
         return EINVAL;
-    return hostname().with_shared([&](const auto& name) -> KResultOr<FlatPtr> {
+    return hostname().with_shared([&](const auto& name) -> ErrorOr<FlatPtr> {
         if (size < (name.length() + 1))
             return ENAMETOOLONG;
         TRY(copy_to_user(buffer, name.characters(), name.length() + 1));
@@ -22,7 +22,7 @@ KResultOr<FlatPtr> Process::sys$gethostname(Userspace<char*> buffer, size_t size
     });
 }
 
-KResultOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> buffer, size_t length)
+ErrorOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> buffer, size_t length)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this)
     REQUIRE_NO_PROMISES;
@@ -31,7 +31,7 @@ KResultOr<FlatPtr> Process::sys$sethostname(Userspace<const char*> buffer, size_
     if (length > 64)
         return ENAMETOOLONG;
     auto new_name = TRY(try_copy_kstring_from_user(buffer, length));
-    return hostname().with_exclusive([&](auto& name) -> KResultOr<FlatPtr> {
+    return hostname().with_exclusive([&](auto& name) -> ErrorOr<FlatPtr> {
         // FIXME: Use KString instead of String here.
         name = new_name->view();
         return 0;
diff --git a/Kernel/Syscalls/inode_watcher.cpp b/Kernel/Syscalls/inode_watcher.cpp
index b118d10d536..0634d23a4ec 100644
--- a/Kernel/Syscalls/inode_watcher.cpp
+++ b/Kernel/Syscalls/inode_watcher.cpp
@@ -13,7 +13,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
+ErrorOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(rpath);
@@ -34,7 +34,7 @@ KResultOr<FlatPtr> Process::sys$create_inode_watcher(u32 flags)
     return fd_allocation.fd;
 }
 
-KResultOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall::SC_inode_watcher_add_watch_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(rpath);
@@ -52,13 +52,14 @@ KResultOr<FlatPtr> Process::sys$inode_watcher_add_watch(Userspace<const Syscall:
     return TRY(inode_watcher->register_inode(custody->inode(), params.event_mask));
 }
 
-KResultOr<FlatPtr> Process::sys$inode_watcher_remove_watch(int fd, int wd)
+ErrorOr<FlatPtr> Process::sys$inode_watcher_remove_watch(int fd, int wd)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto description = TRY(fds().open_file_description(fd));
     if (!description->is_inode_watcher())
         return EBADF;
-    return description->inode_watcher()->unregister_by_wd(wd);
+    TRY(description->inode_watcher()->unregister_by_wd(wd));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/ioctl.cpp b/Kernel/Syscalls/ioctl.cpp
index 0f2a675dfd6..f8a804327c5 100644
--- a/Kernel/Syscalls/ioctl.cpp
+++ b/Kernel/Syscalls/ioctl.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
+ErrorOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto description = TRY(fds().open_file_description(fd));
@@ -19,9 +19,10 @@ KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
         int non_blocking;
         TRY(copy_from_user(&non_blocking, Userspace<const int*>(arg)));
         description->set_blocking(non_blocking == 0);
-        return KSuccess;
+        return 0;
     }
-    return description->file().ioctl(*description, request, arg);
+    TRY(description->file().ioctl(*description, request, arg));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/keymap.cpp b/Kernel/Syscalls/keymap.cpp
index 665508456c1..c957f4804a4 100644
--- a/Kernel/Syscalls/keymap.cpp
+++ b/Kernel/Syscalls/keymap.cpp
@@ -11,7 +11,7 @@ namespace Kernel {
 
 constexpr size_t map_name_max_size = 50;
 
-KResultOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
     REQUIRE_PROMISE(setkeymap);
@@ -37,7 +37,7 @@ KResultOr<FlatPtr> Process::sys$setkeymap(Userspace<const Syscall::SC_setkeymap_
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$getkeymap(Userspace<const Syscall::SC_getkeymap_params*> user_params)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     REQUIRE_PROMISE(getkeymap);
@@ -55,7 +55,7 @@ KResultOr<FlatPtr> Process::sys$getkeymap(Userspace<const Syscall::SC_getkeymap_
     if (params.map_name.size < keymap_name.length())
         return ENAMETOOLONG;
     TRY(copy_to_user(params.map_name.data, keymap_name.characters(), keymap_name.length()));
-    return KSuccess;
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/kill.cpp b/Kernel/Syscalls/kill.cpp
index 24339516db7..1d2ff248d18 100644
--- a/Kernel/Syscalls/kill.cpp
+++ b/Kernel/Syscalls/kill.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResult Process::do_kill(Process& process, int signal)
+ErrorOr<void> Process::do_kill(Process& process, int signal)
 {
     // FIXME: Allow sending SIGCONT to everyone in the process group.
     // FIXME: Should setuid processes have some special treatment here?
@@ -21,10 +21,10 @@ KResult Process::do_kill(Process& process, int signal)
     }
     if (signal != 0)
         return process.send_signal(signal, this);
-    return KSuccess;
+    return {};
 }
 
-KResult Process::do_killpg(ProcessGroupID pgrp, int signal)
+ErrorOr<void> Process::do_killpg(ProcessGroupID pgrp, int signal)
 {
     InterruptDisabler disabler;
 
@@ -38,64 +38,64 @@ KResult Process::do_killpg(ProcessGroupID pgrp, int signal)
 
     bool group_was_empty = true;
     bool any_succeeded = false;
-    KResult error = KSuccess;
+    ErrorOr<void> error;
 
     Process::for_each_in_pgrp(pgrp, [&](auto& process) {
         group_was_empty = false;
 
-        KResult res = do_kill(process, signal);
-        if (res.is_success())
+        ErrorOr<void> res = do_kill(process, signal);
+        if (!res.is_error())
             any_succeeded = true;
         else
-            error = res;
+            error = move(res);
     });
 
     if (group_was_empty)
         return ESRCH;
     if (any_succeeded)
-        return KSuccess;
+        return {};
     return error;
 }
 
-KResult Process::do_killall(int signal)
+ErrorOr<void> Process::do_killall(int signal)
 {
     InterruptDisabler disabler;
 
     bool any_succeeded = false;
-    KResult error = KSuccess;
+    ErrorOr<void> error;
 
     // Send the signal to all processes we have access to for.
     processes().for_each([&](auto& process) {
-        KResult res = KSuccess;
+        ErrorOr<void> res;
         if (process.pid() == pid())
             res = do_killself(signal);
         else
             res = do_kill(process, signal);
 
-        if (res.is_success())
+        if (!res.is_error())
             any_succeeded = true;
         else
-            error = res;
+            error = move(res);
     });
 
     if (any_succeeded)
-        return KSuccess;
+        return {};
     return error;
 }
 
-KResult Process::do_killself(int signal)
+ErrorOr<void> Process::do_killself(int signal)
 {
     if (signal == 0)
-        return KSuccess;
+        return {};
 
     auto current_thread = Thread::current();
     if (!current_thread->should_ignore_signal(signal))
         current_thread->send_signal(signal, this);
 
-    return KSuccess;
+    return {};
 }
 
-KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
+ErrorOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     if (pid_or_pgid == pid().value())
@@ -108,21 +108,26 @@ KResultOr<FlatPtr> Process::sys$kill(pid_t pid_or_pgid, int signal)
     if (pid_or_pgid < -1) {
         if (pid_or_pgid == NumericLimits<i32>::min())
             return EINVAL;
-        return do_killpg(-pid_or_pgid, signal);
+        TRY(do_killpg(-pid_or_pgid, signal));
+        return 0;
+    }
+    if (pid_or_pgid == -1) {
+        TRY(do_killall(signal));
+        return 0;
     }
-    if (pid_or_pgid == -1)
-        return do_killall(signal);
     if (pid_or_pgid == pid().value()) {
-        return do_killself(signal);
+        TRY(do_killself(signal));
+        return 0;
     }
     VERIFY(pid_or_pgid >= 0);
     auto peer = Process::from_pid(pid_or_pgid);
     if (!peer)
         return ESRCH;
-    return do_kill(*peer, signal);
+    TRY(do_kill(*peer, signal));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
+ErrorOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -131,7 +136,8 @@ KResultOr<FlatPtr> Process::sys$killpg(pid_t pgrp, int signum)
     if (pgrp < 0)
         return EINVAL;
 
-    return do_killpg(pgrp, signum);
+    TRY(do_killpg(pgrp, signum));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/link.cpp b/Kernel/Syscalls/link.cpp
index 525dd8fe27d..66a39c48c3b 100644
--- a/Kernel/Syscalls/link.cpp
+++ b/Kernel/Syscalls/link.cpp
@@ -10,17 +10,18 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$link(Userspace<const Syscall::SC_link_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(cpath);
     auto params = TRY(copy_typed_from_user(user_params));
     auto old_path = TRY(try_copy_kstring_from_user(params.old_path));
     auto new_path = TRY(try_copy_kstring_from_user(params.new_path));
-    return VirtualFileSystem::the().link(old_path->view(), new_path->view(), current_directory());
+    TRY(VirtualFileSystem::the().link(old_path->view(), new_path->view(), current_directory()));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(cpath);
@@ -28,7 +29,8 @@ KResultOr<FlatPtr> Process::sys$symlink(Userspace<const Syscall::SC_symlink_para
 
     auto target = TRY(get_syscall_path_argument(params.target));
     auto linkpath = TRY(get_syscall_path_argument(params.linkpath));
-    return VirtualFileSystem::the().symlink(target->view(), linkpath->view(), current_directory());
+    TRY(VirtualFileSystem::the().symlink(target->view(), linkpath->view(), current_directory()));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/lseek.cpp b/Kernel/Syscalls/lseek.cpp
index 5f484d5f24d..e2c89301cc1 100644
--- a/Kernel/Syscalls/lseek.cpp
+++ b/Kernel/Syscalls/lseek.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset, int whence)
+ErrorOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset, int whence)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -17,7 +17,8 @@ KResultOr<FlatPtr> Process::sys$lseek(int fd, Userspace<off_t*> userspace_offset
     off_t offset;
     TRY(copy_from_user(&offset, userspace_offset));
     auto seek_result = TRY(description->seek(offset, whence));
-    return copy_to_user(userspace_offset, &seek_result);
+    TRY(copy_to_user(userspace_offset, &seek_result));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/mkdir.cpp b/Kernel/Syscalls/mkdir.cpp
index 2c7bd4665fe..3e68898dd10 100644
--- a/Kernel/Syscalls/mkdir.cpp
+++ b/Kernel/Syscalls/mkdir.cpp
@@ -10,11 +10,12 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$mkdir(Userspace<const char*> user_path, size_t path_length, mode_t mode)
+ErrorOr<FlatPtr> Process::sys$mkdir(Userspace<const char*> user_path, size_t path_length, mode_t mode)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(cpath);
     auto path = TRY(get_syscall_path_argument(user_path, path_length));
-    return VirtualFileSystem::the().mkdir(path->view(), mode & ~umask(), current_directory());
+    TRY(VirtualFileSystem::the().mkdir(path->view(), mode & ~umask(), current_directory()));
+    return 0;
 }
 }
diff --git a/Kernel/Syscalls/mknod.cpp b/Kernel/Syscalls/mknod.cpp
index 4a646b76388..655472b7136 100644
--- a/Kernel/Syscalls/mknod.cpp
+++ b/Kernel/Syscalls/mknod.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(dpath);
@@ -19,7 +19,8 @@ KResultOr<FlatPtr> Process::sys$mknod(Userspace<const Syscall::SC_mknod_params*>
     if (!is_superuser() && !is_regular_file(params.mode) && !is_fifo(params.mode) && !is_socket(params.mode))
         return EPERM;
     auto path = TRY(get_syscall_path_argument(params.path));
-    return VirtualFileSystem::the().mknod(path->view(), params.mode & ~umask(), params.dev, current_directory());
+    TRY(VirtualFileSystem::the().mknod(path->view(), params.mode & ~umask(), params.dev, current_directory()));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/mmap.cpp b/Kernel/Syscalls/mmap.cpp
index 5d6b7576994..e934cc98bae 100644
--- a/Kernel/Syscalls/mmap.cpp
+++ b/Kernel/Syscalls/mmap.cpp
@@ -120,7 +120,7 @@ static bool validate_inode_mmap_prot(const Process& process, int prot, const Ino
     return true;
 }
 
-KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -188,7 +188,7 @@ KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> u
 
     Memory::Region* region = nullptr;
 
-    auto range = TRY([&]() -> KResultOr<Memory::VirtualRange> {
+    auto range = TRY([&]() -> ErrorOr<Memory::VirtualRange> {
         if (map_randomized) {
             return address_space().page_directory().range_allocator().try_allocate_randomized(Memory::page_round_up(size), alignment);
         }
@@ -250,7 +250,7 @@ KResultOr<FlatPtr> Process::sys$mmap(Userspace<const Syscall::SC_mmap_params*> u
     return region->vaddr().get();
 }
 
-static KResultOr<Memory::VirtualRange> expand_range_to_page_boundaries(FlatPtr address, size_t size)
+static ErrorOr<Memory::VirtualRange> expand_range_to_page_boundaries(FlatPtr address, size_t size)
 {
     if (Memory::page_round_up_would_wrap(size))
         return EINVAL;
@@ -267,7 +267,7 @@ static KResultOr<Memory::VirtualRange> expand_range_to_page_boundaries(FlatPtr a
     return Memory::VirtualRange { base, end - base.get() };
 }
 
-KResultOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int prot)
+ErrorOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int prot)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -406,7 +406,7 @@ KResultOr<FlatPtr> Process::sys$mprotect(Userspace<void*> addr, size_t size, int
     return EINVAL;
 }
 
-KResultOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, int advice)
+ErrorOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, int advice)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -441,7 +441,7 @@ KResultOr<FlatPtr> Process::sys$madvise(Userspace<void*> address, size_t size, i
     return EINVAL;
 }
 
-KResultOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mmap_name_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -465,14 +465,15 @@ KResultOr<FlatPtr> Process::sys$set_mmap_name(Userspace<const Syscall::SC_set_mm
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size)
+ErrorOr<FlatPtr> Process::sys$munmap(Userspace<void*> addr, size_t size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
-    return address_space().unmap_mmap_range(VirtualAddress { addr }, size);
+    TRY(address_space().unmap_mmap_range(VirtualAddress { addr }, size));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -509,7 +510,7 @@ KResultOr<FlatPtr> Process::sys$mremap(Userspace<const Syscall::SC_mremap_params
     return ENOTIMPL;
 }
 
-KResultOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data, size_t size)
+ErrorOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data, size_t size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -564,7 +565,7 @@ KResultOr<FlatPtr> Process::sys$allocate_tls(Userspace<const char*> initial_data
     return m_master_tls_region.unsafe_ptr()->vaddr().get();
 }
 
-KResultOr<FlatPtr> Process::sys$msyscall(Userspace<void*> address)
+ErrorOr<FlatPtr> Process::sys$msyscall(Userspace<void*> address)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     if (address_space().enforces_syscall_regions())
diff --git a/Kernel/Syscalls/mount.cpp b/Kernel/Syscalls/mount.cpp
index 343aae3d723..4b12e8034b5 100644
--- a/Kernel/Syscalls/mount.cpp
+++ b/Kernel/Syscalls/mount.cpp
@@ -18,7 +18,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     if (!is_superuser())
@@ -42,19 +42,21 @@ KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*>
 
     if (params.flags & MS_REMOUNT) {
         // We're not creating a new mount, we're updating an existing one!
-        return VirtualFileSystem::the().remount(target_custody, params.flags & ~MS_REMOUNT);
+        TRY(VirtualFileSystem::the().remount(target_custody, params.flags & ~MS_REMOUNT));
+        return 0;
     }
 
     if (params.flags & MS_BIND) {
         // We're doing a bind mount.
         if (description_or_error.is_error())
-            return description_or_error.error();
+            return description_or_error.release_error();
         auto description = description_or_error.release_value();
         if (!description->custody()) {
             // We only support bind-mounting inodes, not arbitrary files.
             return ENODEV;
         }
-        return VirtualFileSystem::the().bind_mount(*description->custody(), target_custody, params.flags);
+        TRY(VirtualFileSystem::the().bind_mount(*description->custody(), target_custody, params.flags));
+        return 0;
     }
 
     RefPtr<FileSystem> fs;
@@ -108,10 +110,11 @@ KResultOr<FlatPtr> Process::sys$mount(Userspace<const Syscall::SC_mount_params*>
         return ENOMEM;
 
     TRY(fs->initialize());
-    return VirtualFileSystem::the().mount(fs.release_nonnull(), target_custody, params.flags);
+    TRY(VirtualFileSystem::the().mount(fs.release_nonnull(), target_custody, params.flags));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, size_t mountpoint_length)
+ErrorOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, size_t mountpoint_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     if (!is_superuser())
@@ -122,7 +125,8 @@ KResultOr<FlatPtr> Process::sys$umount(Userspace<const char*> user_mountpoint, s
     auto mountpoint = TRY(get_syscall_path_argument(user_mountpoint, mountpoint_length));
     auto custody = TRY(VirtualFileSystem::the().resolve_path(mountpoint->view(), current_directory()));
     auto& guest_inode = custody->inode();
-    return VirtualFileSystem::the().unmount(guest_inode);
+    TRY(VirtualFileSystem::the().unmount(guest_inode));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/open.cpp b/Kernel/Syscalls/open.cpp
index 9dd70615053..33b7dad7c9a 100644
--- a/Kernel/Syscalls/open.cpp
+++ b/Kernel/Syscalls/open.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
@@ -64,14 +64,16 @@ KResultOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> u
     return fd_allocation.fd;
 }
 
-KResultOr<FlatPtr> Process::sys$close(int fd)
+ErrorOr<FlatPtr> Process::sys$close(int fd)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     auto description = TRY(fds().open_file_description(fd));
     auto result = description->close();
     m_fds[fd] = {};
-    return result;
+    if (result.is_error())
+        return result.release_error();
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/perf_event.cpp b/Kernel/Syscalls/perf_event.cpp
index c4783a5f180..8f6bb919368 100644
--- a/Kernel/Syscalls/perf_event.cpp
+++ b/Kernel/Syscalls/perf_event.cpp
@@ -9,21 +9,22 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2)
+ErrorOr<FlatPtr> Process::sys$perf_event(int type, FlatPtr arg1, FlatPtr arg2)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto* events_buffer = current_perf_events_buffer();
     if (!events_buffer)
-        return KSuccess;
-    return events_buffer->append(type, arg1, arg2, nullptr);
+        return 0;
+    TRY(events_buffer->append(type, arg1, arg2, nullptr));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$perf_register_string(Userspace<char const*> user_string, size_t user_string_length)
+ErrorOr<FlatPtr> Process::sys$perf_register_string(Userspace<char const*> user_string, size_t user_string_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto* events_buffer = current_perf_events_buffer();
     if (!events_buffer)
-        return KSuccess;
+        return 0;
 
     auto string = TRY(try_copy_kstring_from_user(user_string, user_string_length));
     return events_buffer->register_string(move(string));
diff --git a/Kernel/Syscalls/pipe.cpp b/Kernel/Syscalls/pipe.cpp
index 5363d3d7d25..e517bf2d729 100644
--- a/Kernel/Syscalls/pipe.cpp
+++ b/Kernel/Syscalls/pipe.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags)
+ErrorOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -40,7 +40,7 @@ KResultOr<FlatPtr> Process::sys$pipe(int pipefd[2], int flags)
 
     TRY(copy_to_user(&pipefd[0], &reader_fd_allocation.fd));
     TRY(copy_to_user(&pipefd[1], &writer_fd_allocation.fd));
-    return KSuccess;
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/pledge.cpp b/Kernel/Syscalls/pledge.cpp
index 0d75d048f02..91c7306ad48 100644
--- a/Kernel/Syscalls/pledge.cpp
+++ b/Kernel/Syscalls/pledge.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$pledge(Userspace<const Syscall::SC_pledge_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$pledge(Userspace<const Syscall::SC_pledge_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
diff --git a/Kernel/Syscalls/prctl.cpp b/Kernel/Syscalls/prctl.cpp
index 13cb8be8f22..5d7d69d236e 100644
--- a/Kernel/Syscalls/prctl.cpp
+++ b/Kernel/Syscalls/prctl.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$prctl(int option, FlatPtr arg1, [[maybe_unused]] FlatPtr arg2)
+ErrorOr<FlatPtr> Process::sys$prctl(int option, FlatPtr arg1, [[maybe_unused]] FlatPtr arg2)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     switch (option) {
diff --git a/Kernel/Syscalls/process.cpp b/Kernel/Syscalls/process.cpp
index f2301b41298..f3565f71882 100644
--- a/Kernel/Syscalls/process.cpp
+++ b/Kernel/Syscalls/process.cpp
@@ -9,31 +9,32 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$getpid()
+ErrorOr<FlatPtr> Process::sys$getpid()
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this)
     REQUIRE_PROMISE(stdio);
     return pid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$getppid()
+ErrorOr<FlatPtr> Process::sys$getppid()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     return m_protected_values.ppid.value();
 }
 
-KResultOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t buffer_size)
+ErrorOr<FlatPtr> Process::sys$get_process_name(Userspace<char*> buffer, size_t buffer_size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     if (m_name->length() + 1 > buffer_size)
         return ENAMETOOLONG;
 
-    return copy_to_user(buffer, m_name->characters(), m_name->length() + 1);
+    TRY(copy_to_user(buffer, m_name->characters(), m_name->length() + 1));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length)
+ErrorOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_name, size_t user_name_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -47,7 +48,7 @@ KResultOr<FlatPtr> Process::sys$set_process_name(Userspace<const char*> user_nam
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::SC_set_coredump_metadata_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
@@ -58,7 +59,8 @@ KResultOr<FlatPtr> Process::sys$set_coredump_metadata(Userspace<const Syscall::S
         return EINVAL;
     auto key = TRY(try_copy_kstring_from_user(params.key));
     auto value = TRY(try_copy_kstring_from_user(params.value));
-    return set_coredump_property(move(key), move(value));
+    TRY(set_coredump_property(move(key), move(value)));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/profiling.cpp b/Kernel/Syscalls/profiling.cpp
index 45153f68fd9..5376772bc6d 100644
--- a/Kernel/Syscalls/profiling.cpp
+++ b/Kernel/Syscalls/profiling.cpp
@@ -16,7 +16,7 @@ bool g_profiling_all_threads;
 PerformanceEventBuffer* g_global_perf_events;
 u64 g_profiling_event_mask;
 
-KResultOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
+ErrorOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_NO_PROMISES;
@@ -66,7 +66,7 @@ KResultOr<FlatPtr> Process::sys$profiling_enable(pid_t pid, u64 event_mask)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
+ErrorOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_NO_PROMISES;
@@ -96,7 +96,7 @@ KResultOr<FlatPtr> Process::sys$profiling_disable(pid_t pid)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$profiling_free_buffer(pid_t pid)
+ErrorOr<FlatPtr> Process::sys$profiling_free_buffer(pid_t pid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_NO_PROMISES;
diff --git a/Kernel/Syscalls/ptrace.cpp b/Kernel/Syscalls/ptrace.cpp
index 3f698027bb1..19cd8043c45 100644
--- a/Kernel/Syscalls/ptrace.cpp
+++ b/Kernel/Syscalls/ptrace.cpp
@@ -16,7 +16,7 @@
 
 namespace Kernel {
 
-static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& params, Process& caller)
+static ErrorOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& params, Process& caller)
 {
     SpinlockLocker scheduler_lock(g_scheduler_lock);
     if (params.request == PT_TRACE_ME) {
@@ -24,7 +24,7 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
             return EBUSY;
 
         caller.set_wait_for_tracer_at_next_execve(true);
-        return KSuccess;
+        return 0;
     }
 
     // FIXME: PID/TID BUG
@@ -57,7 +57,7 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
         if (peer->state() != Thread::State::Stopped) {
             peer->send_signal(SIGSTOP, &caller);
         }
-        return KSuccess;
+        return 0;
     }
 
     auto* tracer = peer_process.tracer();
@@ -126,7 +126,8 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
     case PT_POKE:
         if (!Memory::is_user_address(VirtualAddress { params.addr }))
             return EFAULT;
-        return peer->process().poke_user_data(Userspace<u32*> { (FlatPtr)params.addr }, params.data);
+        TRY(peer->process().poke_user_data(Userspace<u32*> { (FlatPtr)params.addr }, params.data));
+        return 0;
 
     case PT_PEEKDEBUG: {
         Kernel::Syscall::SC_ptrace_peek_params peek_params {};
@@ -136,22 +137,23 @@ static KResultOr<u32> handle_ptrace(const Kernel::Syscall::SC_ptrace_params& par
         break;
     }
     case PT_POKEDEBUG:
-        return peer->poke_debug_register(reinterpret_cast<uintptr_t>(params.addr), params.data);
+        TRY(peer->poke_debug_register(reinterpret_cast<uintptr_t>(params.addr), params.data));
+        return 0;
     default:
         return EINVAL;
     }
 
-    return KSuccess;
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(ptrace);
     auto params = TRY(copy_typed_from_user(user_params));
 
     auto result = handle_ptrace(params, *this);
-    return result.is_error() ? result.error().error() : result.value();
+    return result.is_error() ? result.error().code() : result.value();
 }
 
 /**
@@ -164,7 +166,7 @@ bool Process::has_tracee_thread(ProcessID tracer_pid)
     return false;
 }
 
-KResultOr<u32> Process::peek_user_data(Userspace<const u32*> address)
+ErrorOr<u32> Process::peek_user_data(Userspace<const u32*> address)
 {
     // This function can be called from the context of another
     // process that called PT_PEEK
@@ -174,7 +176,7 @@ KResultOr<u32> Process::peek_user_data(Userspace<const u32*> address)
     return data;
 }
 
-KResult Process::poke_user_data(Userspace<u32*> address, u32 data)
+ErrorOr<void> Process::poke_user_data(Userspace<u32*> address, u32 data)
 {
     Memory::VirtualRange range = { VirtualAddress(address), sizeof(u32) };
     auto* region = address_space().find_region_containing(range);
@@ -204,7 +206,7 @@ KResult Process::poke_user_data(Userspace<u32*> address, u32 data)
     return copy_to_user(address, &data);
 }
 
-KResultOr<u32> Thread::peek_debug_register(u32 register_index)
+ErrorOr<u32> Thread::peek_debug_register(u32 register_index)
 {
     u32 data;
     switch (register_index) {
@@ -232,7 +234,7 @@ KResultOr<u32> Thread::peek_debug_register(u32 register_index)
     return data;
 }
 
-KResult Thread::poke_debug_register(u32 register_index, u32 data)
+ErrorOr<void> Thread::poke_debug_register(u32 register_index, u32 data)
 {
     switch (register_index) {
     case 0:
@@ -253,7 +255,7 @@ KResult Thread::poke_debug_register(u32 register_index, u32 data)
     default:
         return EINVAL;
     }
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/Syscalls/purge.cpp b/Kernel/Syscalls/purge.cpp
index b71d3f29c4c..8a0a05cde02 100644
--- a/Kernel/Syscalls/purge.cpp
+++ b/Kernel/Syscalls/purge.cpp
@@ -12,7 +12,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$purge(int mode)
+ErrorOr<FlatPtr> Process::sys$purge(int mode)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_NO_PROMISES;
@@ -22,7 +22,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
     if (mode & PURGE_ALL_VOLATILE) {
         NonnullRefPtrVector<Memory::AnonymousVMObject> vmobjects;
         {
-            KResult result(KSuccess);
+            ErrorOr<void> result;
             Memory::MemoryManager::for_each_vmobject([&](auto& vmobject) {
                 if (vmobject.is_anonymous()) {
                     // In the event that the append fails, only attempt to continue
@@ -36,7 +36,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
             });
 
             if (result.is_error())
-                return result.error();
+                return result.release_error();
         }
         for (auto& vmobject : vmobjects) {
             purged_page_count += vmobject.purge();
@@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
     if (mode & PURGE_ALL_CLEAN_INODE) {
         NonnullRefPtrVector<Memory::InodeVMObject> vmobjects;
         {
-            KResult result(KSuccess);
+            ErrorOr<void> result;
             Memory::MemoryManager::for_each_vmobject([&](auto& vmobject) {
                 if (vmobject.is_inode()) {
                     // In the event that the append fails, only attempt to continue
@@ -59,7 +59,7 @@ KResultOr<FlatPtr> Process::sys$purge(int mode)
             });
 
             if (result.is_error())
-                return result.error();
+                return result.release_error();
         }
         for (auto& vmobject : vmobjects) {
             purged_page_count += vmobject.release_all_clean_pages();
diff --git a/Kernel/Syscalls/read.cpp b/Kernel/Syscalls/read.cpp
index 444c3daa020..c3e8700aa75 100644
--- a/Kernel/Syscalls/read.cpp
+++ b/Kernel/Syscalls/read.cpp
@@ -12,7 +12,7 @@ namespace Kernel {
 
 using BlockFlags = Thread::FileBlocker::BlockFlags;
 
-static KResultOr<OpenFileDescription*> open_readable_file_description(Process::OpenFileDescriptions const& fds, int fd)
+static ErrorOr<OpenFileDescription*> open_readable_file_description(Process::OpenFileDescriptions const& fds, int fd)
 {
     auto description = TRY(fds.open_file_description(fd));
     if (!description->is_readable())
@@ -22,7 +22,7 @@ static KResultOr<OpenFileDescription*> open_readable_file_description(Process::O
     return description;
 }
 
-static KResult check_blocked_read(OpenFileDescription* description)
+static ErrorOr<void> check_blocked_read(OpenFileDescription* description)
 {
     if (description->is_blocking()) {
         if (!description->can_read()) {
@@ -34,10 +34,10 @@ static KResult check_blocked_read(OpenFileDescription* description)
             // TODO: handle exceptions in unblock_flags
         }
     }
-    return KSuccess;
+    return {};
 }
 
-KResultOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
+ErrorOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -74,7 +74,7 @@ KResultOr<FlatPtr> Process::sys$readv(int fd, Userspace<const struct iovec*> iov
     return nread;
 }
 
-KResultOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
+ErrorOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -91,7 +91,7 @@ KResultOr<FlatPtr> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
     return TRY(description->read(user_buffer.value(), size));
 }
 
-KResultOr<FlatPtr> Process::sys$pread(int fd, Userspace<u8*> buffer, size_t size, off_t offset)
+ErrorOr<FlatPtr> Process::sys$pread(int fd, Userspace<u8*> buffer, size_t size, off_t offset)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/readlink.cpp b/Kernel/Syscalls/readlink.cpp
index 21b4a570fdc..e96cc75e5a5 100644
--- a/Kernel/Syscalls/readlink.cpp
+++ b/Kernel/Syscalls/readlink.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$readlink(Userspace<const Syscall::SC_readlink_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$readlink(Userspace<const Syscall::SC_readlink_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(rpath);
diff --git a/Kernel/Syscalls/realpath.cpp b/Kernel/Syscalls/realpath.cpp
index cf219bc1a00..b04cd0e317a 100644
--- a/Kernel/Syscalls/realpath.cpp
+++ b/Kernel/Syscalls/realpath.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$realpath(Userspace<const Syscall::SC_realpath_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$realpath(Userspace<const Syscall::SC_realpath_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(rpath);
diff --git a/Kernel/Syscalls/rename.cpp b/Kernel/Syscalls/rename.cpp
index efd22f7899e..7827e7cd5e1 100644
--- a/Kernel/Syscalls/rename.cpp
+++ b/Kernel/Syscalls/rename.cpp
@@ -10,14 +10,15 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$rename(Userspace<const Syscall::SC_rename_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$rename(Userspace<const Syscall::SC_rename_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(cpath);
     auto params = TRY(copy_typed_from_user(user_params));
     auto old_path = TRY(get_syscall_path_argument(params.old_path));
     auto new_path = TRY(get_syscall_path_argument(params.new_path));
-    return VirtualFileSystem::the().rename(old_path->view(), new_path->view(), current_directory());
+    TRY(VirtualFileSystem::the().rename(old_path->view(), new_path->view(), current_directory()));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/rmdir.cpp b/Kernel/Syscalls/rmdir.cpp
index 493a82dd47b..dfa68b38b40 100644
--- a/Kernel/Syscalls/rmdir.cpp
+++ b/Kernel/Syscalls/rmdir.cpp
@@ -10,12 +10,13 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$rmdir(Userspace<const char*> user_path, size_t path_length)
+ErrorOr<FlatPtr> Process::sys$rmdir(Userspace<const char*> user_path, size_t path_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(cpath);
     auto path = TRY(get_syscall_path_argument(user_path, path_length));
-    return VirtualFileSystem::the().rmdir(path->view(), current_directory());
+    TRY(VirtualFileSystem::the().rmdir(path->view(), current_directory()));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/sched.cpp b/Kernel/Syscalls/sched.cpp
index 270e15fcd16..cc2b7d568d3 100644
--- a/Kernel/Syscalls/sched.cpp
+++ b/Kernel/Syscalls/sched.cpp
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$yield()
+ErrorOr<FlatPtr> Process::sys$yield()
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this);
     REQUIRE_PROMISE(stdio);
@@ -16,7 +16,7 @@ KResultOr<FlatPtr> Process::sys$yield()
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct sched_param*> user_param)
+ErrorOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct sched_param*> user_param)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -41,7 +41,7 @@ KResultOr<FlatPtr> Process::sys$sched_setparam(int pid, Userspace<const struct s
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched_param*> user_param)
+ErrorOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched_param*> user_param)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -68,7 +68,8 @@ KResultOr<FlatPtr> Process::sys$sched_getparam(pid_t pid, Userspace<struct sched
         priority
     };
 
-    return copy_to_user(user_param, &param);
+    TRY(copy_to_user(user_param, &param));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/select.cpp b/Kernel/Syscalls/select.cpp
index 2073e5c1eab..5bfbba84f99 100644
--- a/Kernel/Syscalls/select.cpp
+++ b/Kernel/Syscalls/select.cpp
@@ -14,7 +14,7 @@ namespace Kernel {
 
 using BlockFlags = Thread::FileBlocker::BlockFlags;
 
-KResultOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -121,7 +121,7 @@ KResultOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params
     return marked_fd_count;
 }
 
-KResultOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/sendfd.cpp b/Kernel/Syscalls/sendfd.cpp
index 99b8cab240d..bc66ff7e664 100644
--- a/Kernel/Syscalls/sendfd.cpp
+++ b/Kernel/Syscalls/sendfd.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
+ErrorOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(sendfd);
@@ -25,10 +25,11 @@ KResultOr<FlatPtr> Process::sys$sendfd(int sockfd, int fd)
 
     auto passing_description = TRY(fds().open_file_description(fd));
     auto& local_socket = static_cast<LocalSocket&>(socket);
-    return local_socket.sendfd(*socket_description, move(passing_description));
+    TRY(local_socket.sendfd(*socket_description, move(passing_description)));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$recvfd(int sockfd, int options)
+ErrorOr<FlatPtr> Process::sys$recvfd(int sockfd, int options)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(recvfd);
diff --git a/Kernel/Syscalls/setpgid.cpp b/Kernel/Syscalls/setpgid.cpp
index 73161452081..7aaf54d0778 100644
--- a/Kernel/Syscalls/setpgid.cpp
+++ b/Kernel/Syscalls/setpgid.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$getsid(pid_t pid)
+ErrorOr<FlatPtr> Process::sys$getsid(pid_t pid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -24,7 +24,7 @@ KResultOr<FlatPtr> Process::sys$getsid(pid_t pid)
     return process->sid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$setsid()
+ErrorOr<FlatPtr> Process::sys$setsid()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$setsid()
     return sid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$getpgid(pid_t pid)
+ErrorOr<FlatPtr> Process::sys$getpgid(pid_t pid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -57,7 +57,7 @@ KResultOr<FlatPtr> Process::sys$getpgid(pid_t pid)
     return process->pgid().value();
 }
 
-KResultOr<FlatPtr> Process::sys$getpgrp()
+ErrorOr<FlatPtr> Process::sys$getpgrp()
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -77,7 +77,7 @@ SessionID Process::get_sid_from_pgid(ProcessGroupID pgid)
     return sid;
 }
 
-KResultOr<FlatPtr> Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
+ErrorOr<FlatPtr> Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
diff --git a/Kernel/Syscalls/setuid.cpp b/Kernel/Syscalls/setuid.cpp
index 43ee9fce8e9..0019465591d 100644
--- a/Kernel/Syscalls/setuid.cpp
+++ b/Kernel/Syscalls/setuid.cpp
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$seteuid(UserID new_euid)
+ErrorOr<FlatPtr> Process::sys$seteuid(UserID new_euid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
@@ -25,7 +25,7 @@ KResultOr<FlatPtr> Process::sys$seteuid(UserID new_euid)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setegid(GroupID new_egid)
+ErrorOr<FlatPtr> Process::sys$setegid(GroupID new_egid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
@@ -41,7 +41,7 @@ KResultOr<FlatPtr> Process::sys$setegid(GroupID new_egid)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setuid(UserID new_uid)
+ErrorOr<FlatPtr> Process::sys$setuid(UserID new_uid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
@@ -59,7 +59,7 @@ KResultOr<FlatPtr> Process::sys$setuid(UserID new_uid)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setgid(GroupID new_gid)
+ErrorOr<FlatPtr> Process::sys$setgid(GroupID new_gid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
@@ -77,7 +77,7 @@ KResultOr<FlatPtr> Process::sys$setgid(GroupID new_gid)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setreuid(UserID new_ruid, UserID new_euid)
+ErrorOr<FlatPtr> Process::sys$setreuid(UserID new_ruid, UserID new_euid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
@@ -103,7 +103,7 @@ KResultOr<FlatPtr> Process::sys$setreuid(UserID new_ruid, UserID new_euid)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setresuid(UserID new_ruid, UserID new_euid, UserID new_suid)
+ErrorOr<FlatPtr> Process::sys$setresuid(UserID new_ruid, UserID new_euid, UserID new_suid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
@@ -129,7 +129,7 @@ KResultOr<FlatPtr> Process::sys$setresuid(UserID new_ruid, UserID new_euid, User
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setresgid(GroupID new_rgid, GroupID new_egid, GroupID new_sgid)
+ErrorOr<FlatPtr> Process::sys$setresgid(GroupID new_rgid, GroupID new_egid, GroupID new_sgid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
@@ -155,7 +155,7 @@ KResultOr<FlatPtr> Process::sys$setresgid(GroupID new_rgid, GroupID new_egid, Gr
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
+ErrorOr<FlatPtr> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(id);
diff --git a/Kernel/Syscalls/sigaction.cpp b/Kernel/Syscalls/sigaction.cpp
index 4a7fe5dbf46..7c19b3c2492 100644
--- a/Kernel/Syscalls/sigaction.cpp
+++ b/Kernel/Syscalls/sigaction.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set)
+ErrorOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*> set, Userspace<sigset_t*> old_set)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(sigaction);
@@ -41,15 +41,16 @@ KResultOr<FlatPtr> Process::sys$sigprocmask(int how, Userspace<const sigset_t*>
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set)
+ErrorOr<FlatPtr> Process::sys$sigpending(Userspace<sigset_t*> set)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     auto pending_signals = Thread::current()->pending_signals();
-    return copy_to_user(set, &pending_signals);
+    TRY(copy_to_user(set, &pending_signals));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*> user_act, Userspace<sigaction*> user_old_act)
+ErrorOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*> user_act, Userspace<sigaction*> user_old_act)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(sigaction);
@@ -73,24 +74,24 @@ KResultOr<FlatPtr> Process::sys$sigaction(int signum, Userspace<const sigaction*
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& registers)
+ErrorOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& registers)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     SmapDisabler disabler;
 
 #if ARCH(I386)
-    //Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
+    // Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
     u32* stack_ptr = (u32*)registers.userspace_esp;
     u32 smuggled_eax = *stack_ptr;
 
-    //pop the stored eax, ebp, return address, handler and signal code
+    // pop the stored eax, ebp, return address, handler and signal code
     stack_ptr += 5;
 
     Thread::current()->m_signal_mask = *stack_ptr;
     stack_ptr++;
 
-    //pop edi, esi, ebp, esp, ebx, edx, ecx and eax
+    // pop edi, esi, ebp, esp, ebx, edx, ecx and eax
     memcpy(&registers.edi, stack_ptr, 8 * sizeof(FlatPtr));
     stack_ptr += 8;
 
@@ -103,17 +104,17 @@ KResultOr<FlatPtr> Process::sys$sigreturn([[maybe_unused]] RegisterState& regist
     registers.userspace_esp = registers.esp;
     return smuggled_eax;
 #else
-    //Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
+    // Here, we restore the state pushed by dispatch signal and asm_signal_trampoline.
     FlatPtr* stack_ptr = (FlatPtr*)registers.userspace_rsp;
     FlatPtr smuggled_rax = *stack_ptr;
 
-    //pop the stored rax, rbp, return address, handler and signal code
+    // pop the stored rax, rbp, return address, handler and signal code
     stack_ptr += 5;
 
     Thread::current()->m_signal_mask = *stack_ptr;
     stack_ptr++;
 
-    //pop rdi, rsi, rbp, rsp, rbx, rdx, rcx, rax, r8, r9, r10, r11, r12, r13, r14 and r15
+    // pop rdi, rsi, rbp, rsp, rbx, rdx, rcx, rax, r8, r9, r10, r11, r12, r13, r14 and r15
     memcpy(&registers.rdi, stack_ptr, 16 * sizeof(FlatPtr));
     stack_ptr += 16;
 
diff --git a/Kernel/Syscalls/socket.cpp b/Kernel/Syscalls/socket.cpp
index d06664de7f4..a710637ecd7 100644
--- a/Kernel/Syscalls/socket.cpp
+++ b/Kernel/Syscalls/socket.cpp
@@ -31,7 +31,7 @@ void Process::setup_socket_fd(int fd, NonnullRefPtr<OpenFileDescription> descrip
     m_fds[fd].set(*description, flags);
 }
 
-KResultOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
+ErrorOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(domain);
@@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$socket(int domain, int type, int protocol)
     return fd_allocation.fd;
 }
 
-KResultOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> address, socklen_t address_length)
+ErrorOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> address, socklen_t address_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto description = TRY(fds().open_file_description(sockfd));
@@ -53,10 +53,11 @@ KResultOr<FlatPtr> Process::sys$bind(int sockfd, Userspace<const sockaddr*> addr
         return ENOTSOCK;
     auto& socket = *description->socket();
     REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
-    return socket.bind(address, address_length);
+    TRY(socket.bind(address, address_length));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
+ErrorOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     if (backlog < 0)
@@ -68,10 +69,11 @@ KResultOr<FlatPtr> Process::sys$listen(int sockfd, int backlog)
     REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
     if (socket.is_connected())
         return EINVAL;
-    return socket.listen(backlog);
+    TRY(socket.listen(backlog));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(accept);
@@ -129,7 +131,7 @@ KResultOr<FlatPtr> Process::sys$accept4(Userspace<const Syscall::SC_accept4_para
     return fd_allocation.fd;
 }
 
-KResultOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> user_address, socklen_t user_address_size)
+ErrorOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> user_address, socklen_t user_address_size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto description = TRY(fds().open_file_description(sockfd));
@@ -137,10 +139,11 @@ KResultOr<FlatPtr> Process::sys$connect(int sockfd, Userspace<const sockaddr*> u
         return ENOTSOCK;
     auto& socket = *description->socket();
     REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
-    return socket.connect(*description, user_address, user_address_size, description->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No);
+    TRY(socket.connect(*description, user_address, user_address_size, description->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
+ErrorOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -151,10 +154,11 @@ KResultOr<FlatPtr> Process::sys$shutdown(int sockfd, int how)
         return ENOTSOCK;
     auto& socket = *description->socket();
     REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
-    return socket.shutdown(how);
+    TRY(socket.shutdown(how));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
+ErrorOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -182,14 +186,11 @@ KResultOr<FlatPtr> Process::sys$sendmsg(int sockfd, Userspace<const struct msghd
     auto data_buffer = UserOrKernelBuffer::for_user_buffer((u8*)iovs[0].iov_base, iovs[0].iov_len);
     if (!data_buffer.has_value())
         return EFAULT;
-    auto result = socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length);
-    if (result.is_error())
-        return result.error();
-    else
-        return result.release_value();
+    auto bytes_sent = TRY(socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length));
+    return bytes_sent;
 }
 
-KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
+ErrorOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -228,7 +229,7 @@ KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> us
         description->set_blocking(original_blocking);
 
     if (result.is_error())
-        return result.error();
+        return result.release_error();
 
     int msg_flags = 0;
 
@@ -257,7 +258,7 @@ KResultOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> us
 }
 
 template<bool sockname, typename Params>
-KResult Process::get_sock_or_peer_name(const Params& params)
+ErrorOr<void> Process::get_sock_or_peer_name(const Params& params)
 {
     socklen_t addrlen_value;
     TRY(copy_from_user(&addrlen_value, params.addrlen, sizeof(socklen_t)));
@@ -282,21 +283,23 @@ KResult Process::get_sock_or_peer_name(const Params& params)
     return copy_to_user(params.addrlen, &addrlen_value);
 }
 
-KResultOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockname_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$getsockname(Userspace<const Syscall::SC_getsockname_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
-    return get_sock_or_peer_name<true>(params);
+    TRY(get_sock_or_peer_name<true>(params));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeername_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$getpeername(Userspace<const Syscall::SC_getpeername_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
-    return get_sock_or_peer_name<false>(params);
+    TRY(get_sock_or_peer_name<false>(params));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockopt_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
@@ -315,10 +318,11 @@ KResultOr<FlatPtr> Process::sys$getsockopt(Userspace<const Syscall::SC_getsockop
         return ENOTSOCK;
     auto& socket = *description->socket();
     REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
-    return socket.getsockopt(*description, level, option, user_value, user_value_size);
+    TRY(socket.getsockopt(*description, level, option, user_value, user_value_size));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockopt_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
@@ -329,10 +333,11 @@ KResultOr<FlatPtr> Process::sys$setsockopt(Userspace<const Syscall::SC_setsockop
         return ENOTSOCK;
     auto& socket = *description->socket();
     REQUIRE_PROMISE_FOR_SOCKET_DOMAIN(socket.domain());
-    return socket.setsockopt(params.level, params.option, user_value, params.value_size);
+    TRY(socket.setsockopt(params.level, params.option, user_value, params.value_size));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpair_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpair_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
@@ -360,6 +365,6 @@ KResultOr<FlatPtr> Process::sys$socketpair(Userspace<const Syscall::SC_socketpai
         m_fds[fds[1]] = {};
         return EFAULT;
     }
-    return KSuccess;
+    return 0;
 }
 }
diff --git a/Kernel/Syscalls/stat.cpp b/Kernel/Syscalls/stat.cpp
index 8751d9e3a8a..692eb30f7ef 100644
--- a/Kernel/Syscalls/stat.cpp
+++ b/Kernel/Syscalls/stat.cpp
@@ -11,17 +11,18 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf)
+ErrorOr<FlatPtr> Process::sys$fstat(int fd, Userspace<stat*> user_statbuf)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
     auto description = TRY(fds().open_file_description(fd));
     stat buffer = {};
     TRY(description->stat(buffer));
-    return copy_to_user(user_statbuf, &buffer);
+    TRY(copy_to_user(user_statbuf, &buffer));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(rpath);
@@ -43,7 +44,8 @@ KResultOr<FlatPtr> Process::sys$stat(Userspace<const Syscall::SC_stat_params*> u
     auto metadata = TRY(VirtualFileSystem::the().lookup_metadata(path->view(), *base, params.follow_symlinks ? 0 : O_NOFOLLOW_NOERROR));
     stat statbuf = {};
     TRY(metadata.stat(statbuf));
-    return copy_to_user(params.statbuf, &statbuf);
+    TRY(copy_to_user(params.statbuf, &statbuf));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/statvfs.cpp b/Kernel/Syscalls/statvfs.cpp
index 6cfbdc6602e..678ac6f4487 100644
--- a/Kernel/Syscalls/statvfs.cpp
+++ b/Kernel/Syscalls/statvfs.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::do_statvfs(StringView path, statvfs* buf)
+ErrorOr<FlatPtr> Process::do_statvfs(StringView path, statvfs* buf)
 {
     auto custody = TRY(VirtualFileSystem::the().resolve_path(path, current_directory(), nullptr, 0));
     auto& inode = custody->inode();
@@ -58,10 +58,11 @@ KResultOr<FlatPtr> Process::do_statvfs(StringView path, statvfs* buf)
         }
     }
 
-    return copy_to_user(buf, &kernelbuf);
+    TRY(copy_to_user(buf, &kernelbuf));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(rpath);
@@ -71,7 +72,7 @@ KResultOr<FlatPtr> Process::sys$statvfs(Userspace<const Syscall::SC_statvfs_para
     return do_statvfs(path->view(), params.buf);
 }
 
-KResultOr<FlatPtr> Process::sys$fstatvfs(int fd, statvfs* buf)
+ErrorOr<FlatPtr> Process::sys$fstatvfs(int fd, statvfs* buf)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/sync.cpp b/Kernel/Syscalls/sync.cpp
index 0e369e6ff87..8764d685397 100644
--- a/Kernel/Syscalls/sync.cpp
+++ b/Kernel/Syscalls/sync.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$sync()
+ErrorOr<FlatPtr> Process::sys$sync()
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/sysconf.cpp b/Kernel/Syscalls/sysconf.cpp
index 6c6c7b79b51..ebe8b0e54ba 100644
--- a/Kernel/Syscalls/sysconf.cpp
+++ b/Kernel/Syscalls/sysconf.cpp
@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$sysconf(int name)
+ErrorOr<FlatPtr> Process::sys$sysconf(int name)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this)
     switch (name) {
diff --git a/Kernel/Syscalls/thread.cpp b/Kernel/Syscalls/thread.cpp
index baf8be9e50b..9c0f5715aed 100644
--- a/Kernel/Syscalls/thread.cpp
+++ b/Kernel/Syscalls/thread.cpp
@@ -13,7 +13,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$create_thread(void* (*entry)(void*), Userspace<const Syscall::SC_create_thread_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$create_thread(void* (*entry)(void*), Userspace<const Syscall::SC_create_thread_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(thread);
@@ -101,7 +101,7 @@ void Process::sys$exit_thread(Userspace<void*> exit_value, Userspace<void*> stac
     VERIFY_NOT_REACHED();
 }
 
-KResultOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
+ErrorOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(thread);
@@ -116,7 +116,7 @@ KResultOr<FlatPtr> Process::sys$detach_thread(pid_t tid)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_value)
+ErrorOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_value)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(thread);
@@ -133,11 +133,11 @@ KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_va
 
     // NOTE: pthread_join() cannot be interrupted by signals. Only by death.
     for (;;) {
-        KResult try_join_result(KSuccess);
+        ErrorOr<void> try_join_result;
         auto result = current_thread->block<Thread::JoinBlocker>({}, *thread, try_join_result, joinee_exit_value);
         if (result == Thread::BlockResult::NotBlocked) {
             if (try_join_result.is_error())
-                return try_join_result.error();
+                return try_join_result.release_error();
             break;
         }
         if (result == Thread::BlockResult::InterruptedByDeath)
@@ -148,10 +148,10 @@ KResultOr<FlatPtr> Process::sys$join_thread(pid_t tid, Userspace<void**> exit_va
     if (exit_value)
         TRY(copy_to_user(exit_value, &joinee_exit_value));
 
-    return KSuccess;
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
+ErrorOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(thread);
@@ -169,7 +169,7 @@ KResultOr<FlatPtr> Process::sys$kill_thread(pid_t tid, int signal)
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*> user_name, size_t user_name_length)
+ErrorOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*> user_name, size_t user_name_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -188,7 +188,7 @@ KResultOr<FlatPtr> Process::sys$set_thread_name(pid_t tid, Userspace<const char*
     return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size)
+ErrorOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buffer, size_t buffer_size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(thread);
@@ -205,16 +205,17 @@ KResultOr<FlatPtr> Process::sys$get_thread_name(pid_t tid, Userspace<char*> buff
     if (thread_name.is_null()) {
         char null_terminator = '\0';
         TRY(copy_to_user(buffer, &null_terminator, sizeof(null_terminator)));
-        return KSuccess;
+        return 0;
     }
 
     if (thread_name.length() + 1 > buffer_size)
         return ENAMETOOLONG;
 
-    return copy_to_user(buffer, thread_name.characters_without_null_termination(), thread_name.length() + 1);
+    TRY(copy_to_user(buffer, thread_name.characters_without_null_termination(), thread_name.length() + 1));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$gettid()
+ErrorOr<FlatPtr> Process::sys$gettid()
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/times.cpp b/Kernel/Syscalls/times.cpp
index b1161bcd4bb..d8803bda884 100644
--- a/Kernel/Syscalls/times.cpp
+++ b/Kernel/Syscalls/times.cpp
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$times(Userspace<tms*> user_times)
+ErrorOr<FlatPtr> Process::sys$times(Userspace<tms*> user_times)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/ttyname.cpp b/Kernel/Syscalls/ttyname.cpp
index 2e73d06a9c7..123a02498b6 100644
--- a/Kernel/Syscalls/ttyname.cpp
+++ b/Kernel/Syscalls/ttyname.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t size)
+ErrorOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(tty);
@@ -21,10 +21,11 @@ KResultOr<FlatPtr> Process::sys$ttyname(int fd, Userspace<char*> buffer, size_t
     auto& tty_name = description->tty()->tty_name();
     if (size < tty_name.length() + 1)
         return ERANGE;
-    return copy_to_user(buffer, tty_name.characters(), tty_name.length() + 1);
+    TRY(copy_to_user(buffer, tty_name.characters(), tty_name.length() + 1));
+    return 0;
 }
 
-KResultOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t size)
+ErrorOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(tty);
@@ -35,7 +36,8 @@ KResultOr<FlatPtr> Process::sys$ptsname(int fd, Userspace<char*> buffer, size_t
     auto& pts_name = master_pty->pts_name();
     if (size < pts_name.length() + 1)
         return ERANGE;
-    return copy_to_user(buffer, pts_name.characters(), pts_name.length() + 1);
+    TRY(copy_to_user(buffer, pts_name.characters(), pts_name.length() + 1));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/umask.cpp b/Kernel/Syscalls/umask.cpp
index e019fb03446..17cc7e71420 100644
--- a/Kernel/Syscalls/umask.cpp
+++ b/Kernel/Syscalls/umask.cpp
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$umask(mode_t mask)
+ErrorOr<FlatPtr> Process::sys$umask(mode_t mask)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/Syscalls/uname.cpp b/Kernel/Syscalls/uname.cpp
index 4e07697a89d..6a6da056da8 100644
--- a/Kernel/Syscalls/uname.cpp
+++ b/Kernel/Syscalls/uname.cpp
@@ -8,7 +8,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
+ErrorOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
 {
     VERIFY_NO_PROCESS_BIG_LOCK(this)
     REQUIRE_PROMISE(stdio);
@@ -27,7 +27,8 @@ KResultOr<FlatPtr> Process::sys$uname(Userspace<utsname*> user_buf)
         memcpy(buf.nodename, name.characters(), name.length() + 1);
     });
 
-    return copy_to_user(user_buf, &buf);
+    TRY(copy_to_user(user_buf, &buf));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/unlink.cpp b/Kernel/Syscalls/unlink.cpp
index cc23e5c75aa..e23431902cf 100644
--- a/Kernel/Syscalls/unlink.cpp
+++ b/Kernel/Syscalls/unlink.cpp
@@ -10,12 +10,13 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$unlink(Userspace<const char*> user_path, size_t path_length)
+ErrorOr<FlatPtr> Process::sys$unlink(Userspace<const char*> user_path, size_t path_length)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(cpath);
     auto path = TRY(get_syscall_path_argument(user_path, path_length));
-    return VirtualFileSystem::the().unlink(path->view(), current_directory());
+    TRY(VirtualFileSystem::the().unlink(path->view(), current_directory()));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/unveil.cpp b/Kernel/Syscalls/unveil.cpp
index ae067476784..196c7fee542 100644
--- a/Kernel/Syscalls/unveil.cpp
+++ b/Kernel/Syscalls/unveil.cpp
@@ -24,7 +24,7 @@ static void update_intermediate_node_permissions(UnveilNode& root_node, UnveilAc
     }
 }
 
-KResultOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     auto params = TRY(copy_typed_from_user(user_params));
@@ -84,12 +84,12 @@ KResultOr<FlatPtr> Process::sys$unveil(Userspace<const Syscall::SC_unveil_params
     auto custody_or_error = VirtualFileSystem::the().resolve_path_without_veil(path->view(), VirtualFileSystem::the().root_custody(), &parent_custody);
     if (!custody_or_error.is_error()) {
         new_unveiled_path = TRY(custody_or_error.value()->try_serialize_absolute_path());
-    } else if (custody_or_error.error() == ENOENT && parent_custody && (new_permissions & UnveilAccess::CreateOrRemove)) {
+    } else if (custody_or_error.error().code() == ENOENT && parent_custody && (new_permissions & UnveilAccess::CreateOrRemove)) {
         auto parent_custody_path = TRY(parent_custody->try_serialize_absolute_path());
         new_unveiled_path = TRY(KLexicalPath::try_join(parent_custody_path->view(), KLexicalPath::basename(path->view())));
     } else {
         // FIXME Should this be EINVAL?
-        return custody_or_error.error();
+        return custody_or_error.release_error();
     }
 
     auto path_parts = KLexicalPath::parts(new_unveiled_path->view());
diff --git a/Kernel/Syscalls/utime.cpp b/Kernel/Syscalls/utime.cpp
index f10b00ad5b5..a189efe682a 100644
--- a/Kernel/Syscalls/utime.cpp
+++ b/Kernel/Syscalls/utime.cpp
@@ -10,7 +10,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$utime(Userspace<const char*> user_path, size_t path_length, Userspace<const struct utimbuf*> user_buf)
+ErrorOr<FlatPtr> Process::sys$utime(Userspace<const char*> user_path, size_t path_length, Userspace<const struct utimbuf*> user_buf)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(fattr);
@@ -23,7 +23,8 @@ KResultOr<FlatPtr> Process::sys$utime(Userspace<const char*> user_path, size_t p
         // Not a bug!
         buf = { now, now };
     }
-    return VirtualFileSystem::the().utime(path->view(), current_directory(), buf.actime, buf.modtime);
+    TRY(VirtualFileSystem::the().utime(path->view(), current_directory(), buf.actime, buf.modtime));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/waitid.cpp b/Kernel/Syscalls/waitid.cpp
index 6bdfe1aa063..b40f1c11598 100644
--- a/Kernel/Syscalls/waitid.cpp
+++ b/Kernel/Syscalls/waitid.cpp
@@ -10,16 +10,16 @@
 
 namespace Kernel {
 
-KResultOr<siginfo_t> Process::do_waitid(Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, int options)
+ErrorOr<siginfo_t> Process::do_waitid(Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, int options)
 {
-    KResultOr<siginfo_t> result = KResult(KSuccess);
+    ErrorOr<siginfo_t> result = siginfo_t {};
     if (Thread::current()->block<Thread::WaitBlocker>({}, options, move(waitee), result).was_interrupted())
         return EINTR;
-    VERIFY(!result.is_error() || (options & WNOHANG) || result.error() != KSuccess);
+    VERIFY(!result.is_error() || (options & WNOHANG));
     return result;
 }
 
-KResultOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params*> user_params)
+ErrorOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params*> user_params)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(proc);
@@ -55,7 +55,8 @@ KResultOr<FlatPtr> Process::sys$waitid(Userspace<const Syscall::SC_waitid_params
     dbgln_if(PROCESS_DEBUG, "sys$waitid({}, {}, {}, {})", params.idtype, params.id, params.infop, params.options);
 
     auto siginfo = TRY(do_waitid(move(waitee), params.options));
-    return copy_to_user(params.infop, &siginfo);
+    TRY(copy_to_user(params.infop, &siginfo));
+    return 0;
 }
 
 }
diff --git a/Kernel/Syscalls/write.cpp b/Kernel/Syscalls/write.cpp
index 6a94b0fa9b5..991d0c68023 100644
--- a/Kernel/Syscalls/write.cpp
+++ b/Kernel/Syscalls/write.cpp
@@ -11,7 +11,7 @@
 
 namespace Kernel {
 
-KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
+ErrorOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
@@ -45,7 +45,7 @@ KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> io
         auto result = do_write(*description, buffer.value(), vec.iov_len);
         if (result.is_error()) {
             if (nwritten == 0)
-                return result.error();
+                return result.release_error();
             return nwritten;
         }
         nwritten += result.value();
@@ -54,7 +54,7 @@ KResultOr<FlatPtr> Process::sys$writev(int fd, Userspace<const struct iovec*> io
     return nwritten;
 }
 
-KResultOr<FlatPtr> Process::do_write(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
+ErrorOr<FlatPtr> Process::do_write(OpenFileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
 {
     size_t total_nwritten = 0;
 
@@ -81,9 +81,9 @@ KResultOr<FlatPtr> Process::do_write(OpenFileDescription& description, const Use
         if (nwritten_or_error.is_error()) {
             if (total_nwritten > 0)
                 return total_nwritten;
-            if (nwritten_or_error.error() == EAGAIN)
+            if (nwritten_or_error.error().code() == EAGAIN)
                 continue;
-            return nwritten_or_error.error();
+            return nwritten_or_error.release_error();
         }
         VERIFY(nwritten_or_error.value() > 0);
         total_nwritten += nwritten_or_error.value();
@@ -91,7 +91,7 @@ KResultOr<FlatPtr> Process::do_write(OpenFileDescription& description, const Use
     return total_nwritten;
 }
 
-KResultOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
+ErrorOr<FlatPtr> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
 {
     VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
     REQUIRE_PROMISE(stdio);
diff --git a/Kernel/TTY/MasterPTY.cpp b/Kernel/TTY/MasterPTY.cpp
index 7f1680bb82d..d4b6c968044 100644
--- a/Kernel/TTY/MasterPTY.cpp
+++ b/Kernel/TTY/MasterPTY.cpp
@@ -16,7 +16,7 @@
 
 namespace Kernel {
 
-KResultOr<NonnullRefPtr<MasterPTY>> MasterPTY::try_create(unsigned int index)
+ErrorOr<NonnullRefPtr<MasterPTY>> MasterPTY::try_create(unsigned int index)
 {
     // FIXME: Don't make a temporary String here
     auto pts_name = TRY(KString::try_create(String::formatted("/dev/pts/{}", index)));
@@ -58,14 +58,14 @@ KString const& MasterPTY::pts_name() const
     return *m_pts_name;
 }
 
-KResultOr<size_t> MasterPTY::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> MasterPTY::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (!m_slave && m_buffer->is_empty())
         return 0;
     return m_buffer->read(buffer, size);
 }
 
-KResultOr<size_t> MasterPTY::write(OpenFileDescription&, u64, const UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> MasterPTY::write(OpenFileDescription&, u64, const UserOrKernelBuffer& buffer, size_t size)
 {
     if (!m_slave)
         return EIO;
@@ -94,7 +94,7 @@ void MasterPTY::notify_slave_closed(Badge<SlavePTY>)
         m_slave = nullptr;
 }
 
-KResultOr<size_t> MasterPTY::on_slave_write(const UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> MasterPTY::on_slave_write(const UserOrKernelBuffer& data, size_t size)
 {
     if (m_closed)
         return EIO;
@@ -108,7 +108,7 @@ bool MasterPTY::can_write_from_slave() const
     return m_buffer->space_for_writing();
 }
 
-KResult MasterPTY::close()
+ErrorOr<void> MasterPTY::close()
 {
     InterruptDisabler disabler;
     // After the closing OpenFileDescription dies, slave is the only thing keeping me alive.
@@ -118,10 +118,10 @@ KResult MasterPTY::close()
     if (m_slave)
         m_slave->hang_up();
 
-    return KSuccess;
+    return {};
 }
 
-KResult MasterPTY::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
+ErrorOr<void> MasterPTY::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
 {
     REQUIRE_PROMISE(tty);
     if (!m_slave)
@@ -131,7 +131,7 @@ KResult MasterPTY::ioctl(OpenFileDescription& description, unsigned request, Use
     return EINVAL;
 }
 
-KResultOr<NonnullOwnPtr<KString>> MasterPTY::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> MasterPTY::pseudo_path(const OpenFileDescription&) const
 {
     // FIXME: Replace this and others of this pattern by KString::formatted()
     return KString::try_create(String::formatted("ptm:{}", m_pts_name));
diff --git a/Kernel/TTY/MasterPTY.h b/Kernel/TTY/MasterPTY.h
index cf5f1da616b..6ebe95dd4c6 100644
--- a/Kernel/TTY/MasterPTY.h
+++ b/Kernel/TTY/MasterPTY.h
@@ -16,28 +16,28 @@ class SlavePTY;
 
 class MasterPTY final : public CharacterDevice {
 public:
-    static KResultOr<NonnullRefPtr<MasterPTY>> try_create(unsigned index);
+    static ErrorOr<NonnullRefPtr<MasterPTY>> try_create(unsigned index);
     virtual ~MasterPTY() override;
 
     unsigned index() const { return m_index; }
     KString const& pts_name() const;
-    KResultOr<size_t> on_slave_write(const UserOrKernelBuffer&, size_t);
+    ErrorOr<size_t> on_slave_write(const UserOrKernelBuffer&, size_t);
     bool can_write_from_slave() const;
     void notify_slave_closed(Badge<SlavePTY>);
     bool is_closed() const { return m_closed; }
 
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
 
 private:
     explicit MasterPTY(unsigned index, NonnullOwnPtr<DoubleBuffer> buffer, NonnullOwnPtr<KString> pts_name);
     // ^CharacterDevice
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResult close() override;
+    virtual ErrorOr<void> close() override;
     virtual bool is_master_pty() const override { return true; }
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
     virtual StringView class_name() const override { return "MasterPTY"sv; }
 
     RefPtr<SlavePTY> m_slave;
diff --git a/Kernel/TTY/PTYMultiplexer.cpp b/Kernel/TTY/PTYMultiplexer.cpp
index 22ae1312c02..77578c3b1d8 100644
--- a/Kernel/TTY/PTYMultiplexer.cpp
+++ b/Kernel/TTY/PTYMultiplexer.cpp
@@ -40,9 +40,9 @@ void PTYMultiplexer::initialize()
     the().after_inserting();
 }
 
-KResultOr<NonnullRefPtr<OpenFileDescription>> PTYMultiplexer::open(int options)
+ErrorOr<NonnullRefPtr<OpenFileDescription>> PTYMultiplexer::open(int options)
 {
-    return m_freelist.with_exclusive([&](auto& freelist) -> KResultOr<NonnullRefPtr<OpenFileDescription>> {
+    return m_freelist.with_exclusive([&](auto& freelist) -> ErrorOr<NonnullRefPtr<OpenFileDescription>> {
         if (freelist.is_empty())
             return EBUSY;
 
diff --git a/Kernel/TTY/PTYMultiplexer.h b/Kernel/TTY/PTYMultiplexer.h
index 025d32f7f8c..7b9b3ff150d 100644
--- a/Kernel/TTY/PTYMultiplexer.h
+++ b/Kernel/TTY/PTYMultiplexer.h
@@ -24,9 +24,9 @@ public:
     static PTYMultiplexer& the();
 
     // ^CharacterDevice
-    virtual KResultOr<NonnullRefPtr<OpenFileDescription>> open(int options) override;
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return 0; }
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return 0; }
+    virtual ErrorOr<NonnullRefPtr<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, const UserOrKernelBuffer&, size_t) override { return 0; }
     virtual bool can_read(const OpenFileDescription&, size_t) const override { return true; }
     virtual bool can_write(const OpenFileDescription&, size_t) const override { return true; }
 
diff --git a/Kernel/TTY/SlavePTY.cpp b/Kernel/TTY/SlavePTY.cpp
index 738c777e2e3..200072d4b03 100644
--- a/Kernel/TTY/SlavePTY.cpp
+++ b/Kernel/TTY/SlavePTY.cpp
@@ -78,7 +78,7 @@ void SlavePTY::on_master_write(const UserOrKernelBuffer& buffer, size_t size)
         evaluate_block_conditions();
 }
 
-KResultOr<size_t> SlavePTY::on_tty_write(const UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> SlavePTY::on_tty_write(const UserOrKernelBuffer& data, size_t size)
 {
     m_time_of_last_write = kgettimeofday().to_truncated_seconds();
     return m_master->on_slave_write(data, size);
@@ -96,17 +96,17 @@ bool SlavePTY::can_read(const OpenFileDescription& description, size_t offset) c
     return TTY::can_read(description, offset);
 }
 
-KResultOr<size_t> SlavePTY::read(OpenFileDescription& description, u64 offset, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> SlavePTY::read(OpenFileDescription& description, u64 offset, UserOrKernelBuffer& buffer, size_t size)
 {
     if (m_master->is_closed())
         return 0;
     return TTY::read(description, offset, buffer, size);
 }
 
-KResult SlavePTY::close()
+ErrorOr<void> SlavePTY::close()
 {
     m_master->notify_slave_closed({});
-    return KSuccess;
+    return {};
 }
 
 FileBlockerSet& SlavePTY::blocker_set()
diff --git a/Kernel/TTY/SlavePTY.h b/Kernel/TTY/SlavePTY.h
index c2928a3e25e..4be7373e77f 100644
--- a/Kernel/TTY/SlavePTY.h
+++ b/Kernel/TTY/SlavePTY.h
@@ -28,15 +28,15 @@ public:
 private:
     // ^TTY
     virtual KString const& tty_name() const override;
-    virtual KResultOr<size_t> on_tty_write(const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> on_tty_write(const UserOrKernelBuffer&, size_t) override;
     virtual void echo(u8) override;
 
     // ^CharacterDevice
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
     virtual StringView class_name() const override { return "SlavePTY"sv; }
-    virtual KResult close() override;
+    virtual ErrorOr<void> close() override;
 
     friend class MasterPTY;
     SlavePTY(MasterPTY&, unsigned index, NonnullOwnPtr<KString> pts_name);
diff --git a/Kernel/TTY/TTY.cpp b/Kernel/TTY/TTY.cpp
index dc428433ab3..7153d147724 100644
--- a/Kernel/TTY/TTY.cpp
+++ b/Kernel/TTY/TTY.cpp
@@ -41,7 +41,7 @@ void TTY::set_default_termios()
     memcpy(m_termios.c_cc, ttydefchars, sizeof(ttydefchars));
 }
 
-KResultOr<size_t> TTY::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> TTY::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
 {
     if (Process::current().pgid() != pgid()) {
         // FIXME: Should we propagate this error path somehow?
@@ -80,7 +80,7 @@ KResultOr<size_t> TTY::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffe
     return result;
 }
 
-KResultOr<size_t> TTY::write(OpenFileDescription&, u64, const UserOrKernelBuffer& buffer, size_t size)
+ErrorOr<size_t> TTY::write(OpenFileDescription&, u64, const UserOrKernelBuffer& buffer, size_t size)
 {
     if (m_termios.c_lflag & TOSTOP && Process::current().pgid() != pgid()) {
         [[maybe_unused]] auto rc = Process::current().send_signal(SIGTTOU, nullptr);
@@ -88,7 +88,7 @@ KResultOr<size_t> TTY::write(OpenFileDescription&, u64, const UserOrKernelBuffer
     }
 
     constexpr size_t num_chars = 256;
-    return buffer.read_buffered<num_chars>(size, [&](ReadonlyBytes bytes) -> KResultOr<size_t> {
+    return buffer.read_buffered<num_chars>(size, [&](ReadonlyBytes bytes) -> ErrorOr<size_t> {
         u8 modified_data[num_chars * 2];
         size_t modified_data_size = 0;
         for (const auto& byte : bytes) {
@@ -378,9 +378,9 @@ void TTY::flush_input()
     evaluate_block_conditions();
 }
 
-KResult TTY::set_termios(const termios& t)
+ErrorOr<void> TTY::set_termios(const termios& t)
 {
-    KResult rc = KSuccess;
+    ErrorOr<void> rc;
     m_termios = t;
 
     dbgln_if(TTY_DEBUG, "{} set_termios: ECHO={}, ISIG={}, ICANON={}, ECHOE={}, ECHOK={}, ECHONL={}, ISTRIP={}, ICRNL={}, INLCR={}, IGNCR={}, OPOST={}, ONLCR={}",
@@ -472,7 +472,7 @@ KResult TTY::set_termios(const termios& t)
     return rc;
 }
 
-KResult TTY::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
+ErrorOr<void> TTY::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
 {
     REQUIRE_PROMISE(tty);
     auto& current_process = Process::current();
@@ -513,12 +513,12 @@ KResult TTY::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
         if (process) {
             if (auto parent = Process::from_pid(process->ppid())) {
                 m_original_process_parent = *parent;
-                return KSuccess;
+                return {};
             }
         }
 
         m_original_process_parent = nullptr;
-        return KSuccess;
+        return {};
     }
     case TCGETS: {
         user_termios = static_ptr_cast<termios*>(arg);
@@ -543,7 +543,7 @@ KResult TTY::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
         } else if (operation != TCOFLUSH) {
             return EINVAL;
         }
-        return KSuccess;
+        return {};
     }
     case TIOCGWINSZ:
         user_winsize = static_ptr_cast<winsize*>(arg);
@@ -558,25 +558,25 @@ KResult TTY::ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg)
         winsize ws;
         TRY(copy_from_user(&ws, user_winsize));
         if (ws.ws_col == m_columns && ws.ws_row == m_rows)
-            return KSuccess;
+            return {};
         m_rows = ws.ws_row;
         m_columns = ws.ws_col;
         generate_signal(SIGWINCH);
-        return KSuccess;
+        return {};
     }
     case TIOCSCTTY:
         current_process.set_tty(this);
-        return KSuccess;
+        return {};
     case TIOCSTI:
         return EIO;
     case TIOCNOTTY:
         current_process.set_tty(nullptr);
-        return KSuccess;
+        return {};
     }
     return EINVAL;
 }
 
-KResultOr<NonnullOwnPtr<KString>> TTY::pseudo_path(const OpenFileDescription&) const
+ErrorOr<NonnullOwnPtr<KString>> TTY::pseudo_path(const OpenFileDescription&) const
 {
     return tty_name().try_clone();
 }
diff --git a/Kernel/TTY/TTY.h b/Kernel/TTY/TTY.h
index 12f7f3ac26c..0f66f800464 100644
--- a/Kernel/TTY/TTY.h
+++ b/Kernel/TTY/TTY.h
@@ -21,12 +21,12 @@ class TTY : public CharacterDevice {
 public:
     virtual ~TTY() override;
 
-    virtual KResultOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
-    virtual KResultOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
     virtual bool can_read(const OpenFileDescription&, size_t) const override;
     virtual bool can_write(const OpenFileDescription&, size_t) const override;
-    virtual KResult ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override final;
-    virtual KResultOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
+    virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override final;
+    virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
 
     virtual KString const& tty_name() const = 0;
 
@@ -40,7 +40,7 @@ public:
         return 0;
     }
 
-    KResult set_termios(const termios&);
+    ErrorOr<void> set_termios(const termios&);
     bool should_generate_signals() const { return m_termios.c_lflag & ISIG; }
     bool should_flush_on_signal() const { return !(m_termios.c_lflag & NOFLSH); }
     bool should_echo_input() const { return m_termios.c_lflag & ECHO; }
@@ -50,7 +50,7 @@ public:
     void hang_up();
 
 protected:
-    virtual KResultOr<size_t> on_tty_write(const UserOrKernelBuffer&, size_t) = 0;
+    virtual ErrorOr<size_t> on_tty_write(const UserOrKernelBuffer&, size_t) = 0;
     void set_size(unsigned short columns, unsigned short rows);
 
     TTY(unsigned major, unsigned minor);
diff --git a/Kernel/TTY/VirtualConsole.cpp b/Kernel/TTY/VirtualConsole.cpp
index 9a6d0ddf11a..453ba36da24 100644
--- a/Kernel/TTY/VirtualConsole.cpp
+++ b/Kernel/TTY/VirtualConsole.cpp
@@ -258,7 +258,7 @@ void VirtualConsole::on_key_pressed(KeyEvent event)
     });
 }
 
-KResultOr<size_t> VirtualConsole::on_tty_write(const UserOrKernelBuffer& data, size_t size)
+ErrorOr<size_t> VirtualConsole::on_tty_write(const UserOrKernelBuffer& data, size_t size)
 {
     SpinlockLocker global_lock(ConsoleManagement::the().tty_write_lock());
     auto result = data.read_buffered<512>(size, [&](ReadonlyBytes buffer) {
diff --git a/Kernel/TTY/VirtualConsole.h b/Kernel/TTY/VirtualConsole.h
index d29d123a21b..dd7ce2a99be 100644
--- a/Kernel/TTY/VirtualConsole.h
+++ b/Kernel/TTY/VirtualConsole.h
@@ -91,7 +91,7 @@ private:
     virtual void on_key_pressed(KeyEvent) override;
 
     // ^TTY
-    virtual KResultOr<size_t> on_tty_write(const UserOrKernelBuffer&, size_t) override;
+    virtual ErrorOr<size_t> on_tty_write(const UserOrKernelBuffer&, size_t) override;
     virtual KString const& tty_name() const override { return *m_tty_name; }
     virtual void echo(u8) override;
 
diff --git a/Kernel/Thread.cpp b/Kernel/Thread.cpp
index fa58eae54a4..c529a1c3321 100644
--- a/Kernel/Thread.cpp
+++ b/Kernel/Thread.cpp
@@ -38,7 +38,7 @@ SpinlockProtected<Thread::GlobalList>& Thread::all_instances()
     return *s_list;
 }
 
-KResultOr<NonnullRefPtr<Thread>> Thread::try_create(NonnullRefPtr<Process> process)
+ErrorOr<NonnullRefPtr<Thread>> Thread::try_create(NonnullRefPtr<Process> process)
 {
     auto kernel_stack_region = TRY(MM.allocate_kernel_region(default_kernel_stack_size, {}, Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow));
     kernel_stack_region->set_stack(true);
@@ -805,7 +805,7 @@ static void push_value_on_user_stack(FlatPtr& stack, FlatPtr data)
 {
     stack -= sizeof(FlatPtr);
     auto result = copy_to_user((FlatPtr*)stack, &data);
-    VERIFY(result.is_success());
+    VERIFY(!result.is_error());
 }
 
 void Thread::resume_from_stopped()
@@ -1027,7 +1027,7 @@ RegisterState& Thread::get_register_dump_from_stack()
     return *trap->regs;
 }
 
-KResultOr<NonnullRefPtr<Thread>> Thread::try_clone(Process& process)
+ErrorOr<NonnullRefPtr<Thread>> Thread::try_clone(Process& process)
 {
     auto clone = TRY(Thread::try_create(process));
     auto signal_action_data_span = m_signal_action_data.span();
@@ -1184,11 +1184,11 @@ size_t Thread::thread_specific_region_size() const
     return align_up_to(process().m_master_tls_size, thread_specific_region_alignment()) + sizeof(ThreadSpecificData);
 }
 
-KResult Thread::make_thread_specific_region(Badge<Process>)
+ErrorOr<void> Thread::make_thread_specific_region(Badge<Process>)
 {
     // The process may not require a TLS region, or allocate TLS later with sys$allocate_tls (which is what dynamically loaded programs do)
     if (!process().m_master_tls_region)
-        return KSuccess;
+        return {};
 
     auto range = TRY(process().address_space().try_allocate_range({}, thread_specific_region_size()));
     auto* region = TRY(process().address_space().allocate_region(range, "Thread-specific", PROT_READ | PROT_WRITE));
@@ -1204,7 +1204,7 @@ KResult Thread::make_thread_specific_region(Badge<Process>)
     if (process().m_master_tls_size)
         memcpy(thread_local_storage, process().m_master_tls_region.unsafe_ptr()->vaddr().as_ptr(), process().m_master_tls_size);
 
-    return KSuccess;
+    return {};
 }
 
 RefPtr<Thread> Thread::from_tid(ThreadID tid)
diff --git a/Kernel/Thread.h b/Kernel/Thread.h
index f57a81e59a1..8f8f80fc6aa 100644
--- a/Kernel/Thread.h
+++ b/Kernel/Thread.h
@@ -8,6 +8,7 @@
 
 #include <AK/Concepts.h>
 #include <AK/EnumBits.h>
+#include <AK/Error.h>
 #include <AK/HashMap.h>
 #include <AK/IntrusiveList.h>
 #include <AK/Optional.h>
@@ -19,7 +20,6 @@
 #include <AK/Vector.h>
 #include <AK/WeakPtr.h>
 #include <AK/Weakable.h>
-#include <Kernel/API/KResult.h>
 #include <Kernel/Arch/x86/SafeMem.h>
 #include <Kernel/Debug.h>
 #include <Kernel/FileSystem/InodeIdentifier.h>
@@ -162,7 +162,7 @@ public:
         return Processor::current_thread();
     }
 
-    static KResultOr<NonnullRefPtr<Thread>> try_create(NonnullRefPtr<Process>);
+    static ErrorOr<NonnullRefPtr<Thread>> try_create(NonnullRefPtr<Process>);
     ~Thread();
 
     static RefPtr<Thread> from_tid(ThreadID);
@@ -516,7 +516,7 @@ public:
     friend class JoinBlocker;
     class JoinBlocker final : public Blocker {
     public:
-        explicit JoinBlocker(Thread& joinee, KResult& try_join_result, void*& joinee_exit_value);
+        explicit JoinBlocker(Thread& joinee, ErrorOr<void>& try_join_result, void*& joinee_exit_value);
         virtual Type blocker_type() const override { return Type::Join; }
         virtual StringView state_string() const override { return "Joining"sv; }
         virtual bool can_be_interrupted() const override { return false; }
@@ -529,7 +529,7 @@ public:
     private:
         NonnullRefPtr<Thread> m_joinee;
         void*& m_joinee_exit_value;
-        KResult& m_try_join_result;
+        ErrorOr<void>& m_try_join_result;
         bool m_did_unblock { false };
     };
 
@@ -706,7 +706,7 @@ public:
             Disowned
         };
 
-        WaitBlocker(int wait_options, Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, KResultOr<siginfo_t>& result);
+        WaitBlocker(int wait_options, Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, ErrorOr<siginfo_t>& result);
         virtual StringView state_string() const override { return "Waiting"sv; }
         virtual Type blocker_type() const override { return Type::Wait; }
         virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
@@ -721,7 +721,7 @@ public:
         void do_set_result(const siginfo_t&);
 
         const int m_wait_options;
-        KResultOr<siginfo_t>& m_result;
+        ErrorOr<siginfo_t>& m_result;
         Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> m_waitee;
         bool m_did_unblock { false };
         bool m_got_sigchild { false };
@@ -761,7 +761,7 @@ public:
     };
 
     template<typename AddBlockerHandler>
-    KResult try_join(AddBlockerHandler add_blocker)
+    ErrorOr<void> try_join(AddBlockerHandler add_blocker)
     {
         if (Thread::current() == this)
             return EDEADLK;
@@ -776,7 +776,7 @@ public:
         // else. It also means that if the join is timed, it becomes
         // detached when a timeout happens.
         m_is_joinable = false;
-        return KSuccess;
+        return {};
     }
 
     void did_schedule() { ++m_times_scheduled; }
@@ -1011,8 +1011,8 @@ public:
     u32 signal_mask() const;
     void clear_signals();
 
-    KResultOr<u32> peek_debug_register(u32 register_index);
-    KResult poke_debug_register(u32 register_index, u32 data);
+    ErrorOr<u32> peek_debug_register(u32 register_index);
+    ErrorOr<void> poke_debug_register(u32 register_index, u32 data);
 
     void set_dump_backtrace_on_finalization() { m_dump_backtrace_on_finalization = true; }
 
@@ -1028,7 +1028,7 @@ public:
 
     FPUState& fpu_state() { return m_fpu_state; }
 
-    KResult make_thread_specific_region(Badge<Process>);
+    ErrorOr<void> make_thread_specific_region(Badge<Process>);
 
     unsigned syscall_count() const { return m_syscall_count; }
     void did_syscall() { ++m_syscall_count; }
@@ -1104,7 +1104,7 @@ public:
         return !m_is_joinable;
     }
 
-    KResultOr<NonnullRefPtr<Thread>> try_clone(Process&);
+    ErrorOr<NonnullRefPtr<Thread>> try_clone(Process&);
 
     template<IteratorFunction<Thread&> Callback>
     static IterationDecision for_each_in_state(State, Callback);
diff --git a/Kernel/ThreadBlockers.cpp b/Kernel/ThreadBlockers.cpp
index 94711021f79..111746de08d 100644
--- a/Kernel/ThreadBlockers.cpp
+++ b/Kernel/ThreadBlockers.cpp
@@ -68,7 +68,7 @@ auto Thread::Blocker::end_blocking(Badge<Thread>, bool did_timeout) -> BlockResu
     return block_result();
 }
 
-Thread::JoinBlocker::JoinBlocker(Thread& joinee, KResult& try_join_result, void*& joinee_exit_value)
+Thread::JoinBlocker::JoinBlocker(Thread& joinee, ErrorOr<void>& try_join_result, void*& joinee_exit_value)
     : m_joinee(joinee)
     , m_joinee_exit_value(joinee_exit_value)
     , m_try_join_result(try_join_result)
@@ -601,7 +601,7 @@ void Thread::WaitBlockerSet::finalize()
     }
 }
 
-Thread::WaitBlocker::WaitBlocker(int wait_options, Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, KResultOr<siginfo_t>& result)
+Thread::WaitBlocker::WaitBlocker(int wait_options, Variant<Empty, NonnullRefPtr<Process>, NonnullRefPtr<ProcessGroup>> waitee, ErrorOr<siginfo_t>& result)
     : m_wait_options(wait_options)
     , m_result(result)
     , m_waitee(move(waitee))
diff --git a/Kernel/ThreadTracer.h b/Kernel/ThreadTracer.h
index beec018b5cb..ba48b052631 100644
--- a/Kernel/ThreadTracer.h
+++ b/Kernel/ThreadTracer.h
@@ -15,7 +15,7 @@ namespace Kernel {
 
 class ThreadTracer {
 public:
-    static KResultOr<NonnullOwnPtr<ThreadTracer>> try_create(ProcessID tracer) { return adopt_nonnull_own_or_enomem(new (nothrow) ThreadTracer(tracer)); }
+    static ErrorOr<NonnullOwnPtr<ThreadTracer>> try_create(ProcessID tracer) { return adopt_nonnull_own_or_enomem(new (nothrow) ThreadTracer(tracer)); }
 
     ProcessID tracer_pid() const { return m_tracer_pid; }
     bool has_pending_signal(u32 signal) const { return m_pending_signals & (1 << (signal - 1)); }
diff --git a/Kernel/Time/TimeManagement.h b/Kernel/Time/TimeManagement.h
index d2e3a0cc9f2..12cca4ef611 100644
--- a/Kernel/Time/TimeManagement.h
+++ b/Kernel/Time/TimeManagement.h
@@ -6,12 +6,12 @@
 
 #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/KResult.h>
 #include <Kernel/API/TimePage.h>
 #include <Kernel/Arch/RegisterState.h>
 #include <Kernel/UnixTypes.h>
diff --git a/Kernel/UserOrKernelBuffer.cpp b/Kernel/UserOrKernelBuffer.cpp
index ae4953c5bb4..82351924020 100644
--- a/Kernel/UserOrKernelBuffer.cpp
+++ b/Kernel/UserOrKernelBuffer.cpp
@@ -15,7 +15,7 @@ bool UserOrKernelBuffer::is_kernel_buffer() const
     return !Memory::is_user_address(VirtualAddress(m_buffer));
 }
 
-KResultOr<NonnullOwnPtr<KString>> UserOrKernelBuffer::try_copy_into_kstring(size_t size) const
+ErrorOr<NonnullOwnPtr<KString>> UserOrKernelBuffer::try_copy_into_kstring(size_t size) const
 {
     if (!m_buffer)
         return EINVAL;
@@ -29,7 +29,7 @@ KResultOr<NonnullOwnPtr<KString>> UserOrKernelBuffer::try_copy_into_kstring(size
     return KString::try_create(ReadonlyBytes { m_buffer, size });
 }
 
-KResult UserOrKernelBuffer::write(void const* src, size_t offset, size_t len)
+ErrorOr<void> UserOrKernelBuffer::write(void const* src, size_t offset, size_t len)
 {
     if (!m_buffer)
         return EFAULT;
@@ -38,10 +38,10 @@ KResult UserOrKernelBuffer::write(void const* src, size_t offset, size_t len)
         return copy_to_user(m_buffer + offset, src, len);
 
     memcpy(m_buffer + offset, src, len);
-    return KSuccess;
+    return {};
 }
 
-KResult UserOrKernelBuffer::read(void* dest, size_t offset, size_t len) const
+ErrorOr<void> UserOrKernelBuffer::read(void* dest, size_t offset, size_t len) const
 {
     if (!m_buffer)
         return EFAULT;
@@ -50,10 +50,10 @@ KResult UserOrKernelBuffer::read(void* dest, size_t offset, size_t len) const
         return copy_from_user(dest, m_buffer + offset, len);
 
     memcpy(dest, m_buffer + offset, len);
-    return KSuccess;
+    return {};
 }
 
-KResult UserOrKernelBuffer::memset(int value, size_t offset, size_t len)
+ErrorOr<void> UserOrKernelBuffer::memset(int value, size_t offset, size_t len)
 {
     if (!m_buffer)
         return EFAULT;
@@ -62,7 +62,7 @@ KResult UserOrKernelBuffer::memset(int value, size_t offset, size_t len)
         return memset_user(m_buffer + offset, value, len);
 
     ::memset(m_buffer + offset, value, len);
-    return KSuccess;
+    return {};
 }
 
 }
diff --git a/Kernel/UserOrKernelBuffer.h b/Kernel/UserOrKernelBuffer.h
index 1f348f37426..11ffaf8dac0 100644
--- a/Kernel/UserOrKernelBuffer.h
+++ b/Kernel/UserOrKernelBuffer.h
@@ -54,36 +54,36 @@ public:
         return offset_buffer;
     }
 
-    KResultOr<NonnullOwnPtr<KString>> try_copy_into_kstring(size_t) const;
-    KResult write(const void* src, size_t offset, size_t len);
-    KResult write(const void* src, size_t len)
+    ErrorOr<NonnullOwnPtr<KString>> try_copy_into_kstring(size_t) const;
+    ErrorOr<void> write(const void* src, size_t offset, size_t len);
+    ErrorOr<void> write(const void* src, size_t len)
     {
         return write(src, 0, len);
     }
-    KResult write(ReadonlyBytes bytes)
+    ErrorOr<void> write(ReadonlyBytes bytes)
     {
         return write(bytes.data(), bytes.size());
     }
 
-    KResult read(void* dest, size_t offset, size_t len) const;
-    KResult read(void* dest, size_t len) const
+    ErrorOr<void> read(void* dest, size_t offset, size_t len) const;
+    ErrorOr<void> read(void* dest, size_t len) const
     {
         return read(dest, 0, len);
     }
 
-    KResult read(Bytes bytes) const
+    ErrorOr<void> read(Bytes bytes) const
     {
         return read(bytes.data(), bytes.size());
     }
 
-    KResult memset(int value, size_t offset, size_t len);
-    KResult memset(int value, size_t len)
+    ErrorOr<void> memset(int value, size_t offset, size_t len);
+    ErrorOr<void> memset(int value, size_t len)
     {
         return memset(value, 0, len);
     }
 
     template<size_t BUFFER_BYTES, typename F>
-    KResultOr<size_t> write_buffered(size_t offset, size_t len, F f)
+    ErrorOr<size_t> write_buffered(size_t offset, size_t len, F f)
     {
         if (!m_buffer)
             return EFAULT;
@@ -100,10 +100,10 @@ public:
         while (nwritten < len) {
             auto to_copy = min(sizeof(buffer), len - nwritten);
             Bytes bytes { buffer, to_copy };
-            KResultOr<size_t> copied_or_error = f(bytes);
+            ErrorOr<size_t> copied_or_error = f(bytes);
             if (copied_or_error.is_error())
-                return copied_or_error.error();
-            auto copied = copied_or_error.value();
+                return copied_or_error.release_error();
+            auto copied = copied_or_error.release_value();
             VERIFY(copied <= to_copy);
             TRY(write(buffer, nwritten, copied));
             nwritten += copied;
@@ -113,13 +113,13 @@ public:
         return nwritten;
     }
     template<size_t BUFFER_BYTES, typename F>
-    KResultOr<size_t> write_buffered(size_t len, F f)
+    ErrorOr<size_t> write_buffered(size_t len, F f)
     {
         return write_buffered<BUFFER_BYTES, F>(0, len, f);
     }
 
     template<size_t BUFFER_BYTES, typename F>
-    KResultOr<size_t> read_buffered(size_t offset, size_t len, F f) const
+    ErrorOr<size_t> read_buffered(size_t offset, size_t len, F f) const
     {
         if (!m_buffer)
             return EFAULT;
@@ -136,10 +136,10 @@ public:
             auto to_copy = min(sizeof(buffer), len - nread);
             TRY(read(buffer, nread, to_copy));
             ReadonlyBytes read_only_bytes { buffer, to_copy };
-            KResultOr<size_t> copied_or_error = f(read_only_bytes);
+            ErrorOr<size_t> copied_or_error = f(read_only_bytes);
             if (copied_or_error.is_error())
-                return copied_or_error.error();
-            auto copied = copied_or_error.value();
+                return copied_or_error.release_error();
+            auto copied = copied_or_error.release_value();
             VERIFY(copied <= to_copy);
             nread += copied;
             if (copied < to_copy)
@@ -148,7 +148,7 @@ public:
         return nread;
     }
     template<size_t BUFFER_BYTES, typename F>
-    KResultOr<size_t> read_buffered(size_t len, F f) const
+    ErrorOr<size_t> read_buffered(size_t len, F f) const
     {
         return read_buffered<BUFFER_BYTES, F>(0, len, f);
     }