diff --git a/Kernel/FileSystem/FIFO.cpp b/Kernel/FileSystem/FIFO.cpp
index 32d80804e4..6e1f081848 100644
--- a/Kernel/FileSystem/FIFO.cpp
+++ b/Kernel/FileSystem/FIFO.cpp
@@ -32,10 +32,10 @@ Retained<FIFO> FIFO::create(uid_t uid)
 
 Retained<FileDescription> FIFO::open_direction(FIFO::Direction direction)
 {
-    auto descriptor = FileDescription::create(this);
+    auto description = FileDescription::create(this);
     attach(direction);
-    descriptor->set_fifo_direction({}, direction);
-    return descriptor;
+    description->set_fifo_direction({}, direction);
+    return description;
 }
 
 FIFO::FIFO(uid_t uid)
diff --git a/Kernel/FileSystem/FileDescription.cpp b/Kernel/FileSystem/FileDescription.cpp
index b6fd6158be..a75ec14259 100644
--- a/Kernel/FileSystem/FileDescription.cpp
+++ b/Kernel/FileSystem/FileDescription.cpp
@@ -17,9 +17,9 @@
 
 Retained<FileDescription> FileDescription::create(RetainPtr<Custody>&& custody)
 {
-    auto descriptor = adopt(*new FileDescription(InodeFile::create(custody->inode())));
-    descriptor->m_custody = move(custody);
-    return descriptor;
+    auto description = adopt(*new FileDescription(InodeFile::create(custody->inode())));
+    description->m_custody = move(custody);
+    return description;
 }
 
 Retained<FileDescription> FileDescription::create(RetainPtr<File>&& file, SocketRole role)
@@ -60,20 +60,20 @@ void FileDescription::set_socket_role(SocketRole role)
 
 Retained<FileDescription> FileDescription::clone()
 {
-    RetainPtr<FileDescription> descriptor;
+    RetainPtr<FileDescription> description;
     if (is_fifo()) {
-        descriptor = fifo()->open_direction(m_fifo_direction);
+        description = fifo()->open_direction(m_fifo_direction);
     } else {
-        descriptor = FileDescription::create(m_file.copy_ref(), m_socket_role);
-        descriptor->m_custody = m_custody.copy_ref();
-        descriptor->m_inode = m_inode.copy_ref();
+        description = FileDescription::create(m_file.copy_ref(), m_socket_role);
+        description->m_custody = m_custody.copy_ref();
+        description->m_inode = m_inode.copy_ref();
     }
-    ASSERT(descriptor);
-    descriptor->m_current_offset = m_current_offset;
-    descriptor->m_is_blocking = m_is_blocking;
-    descriptor->m_should_append = m_should_append;
-    descriptor->m_file_flags = m_file_flags;
-    return *descriptor;
+    ASSERT(description);
+    description->m_current_offset = m_current_offset;
+    description->m_is_blocking = m_is_blocking;
+    description->m_should_append = m_should_append;
+    description->m_file_flags = m_file_flags;
+    return *description;
 }
 
 KResult FileDescription::fstat(stat& buffer)
diff --git a/Kernel/FileSystem/InodeFile.cpp b/Kernel/FileSystem/InodeFile.cpp
index 6b46feacb0..5dee202e68 100644
--- a/Kernel/FileSystem/InodeFile.cpp
+++ b/Kernel/FileSystem/InodeFile.cpp
@@ -13,32 +13,32 @@ InodeFile::~InodeFile()
 {
 }
 
-ssize_t InodeFile::read(FileDescription& descriptor, byte* buffer, ssize_t count)
+ssize_t InodeFile::read(FileDescription& description, byte* buffer, ssize_t count)
 {
-    return m_inode->read_bytes(descriptor.offset(), count, buffer, &descriptor);
+    return m_inode->read_bytes(description.offset(), count, buffer, &description);
 }
 
-ssize_t InodeFile::write(FileDescription& descriptor, const byte* data, ssize_t count)
+ssize_t InodeFile::write(FileDescription& description, const byte* data, ssize_t count)
 {
-    return m_inode->write_bytes(descriptor.offset(), count, data, &descriptor);
+    return m_inode->write_bytes(description.offset(), count, data, &description);
 }
 
-KResultOr<Region*> InodeFile::mmap(Process& process, FileDescription& descriptor, VirtualAddress preferred_vaddr, size_t offset, size_t size, int prot)
+KResultOr<Region*> InodeFile::mmap(Process& process, FileDescription& description, VirtualAddress preferred_vaddr, size_t offset, size_t size, int prot)
 {
     ASSERT(offset == 0);
     // FIXME: If PROT_EXEC, check that the underlying file system isn't mounted noexec.
     InterruptDisabler disabler;
-    auto* region = process.allocate_file_backed_region(preferred_vaddr, size, inode(), descriptor.absolute_path(), prot);
+    auto* region = process.allocate_file_backed_region(preferred_vaddr, size, inode(), description.absolute_path(), prot);
     if (!region)
         return KResult(-ENOMEM);
     return region;
 }
 
-String InodeFile::absolute_path(const FileDescription& descriptor) const
+String InodeFile::absolute_path(const FileDescription& description) const
 {
     ASSERT_NOT_REACHED();
-    ASSERT(descriptor.custody());
-    return descriptor.absolute_path();
+    ASSERT(description.custody());
+    return description.absolute_path();
 }
 
 KResult InodeFile::truncate(off_t size)
diff --git a/Kernel/FileSystem/ProcFS.cpp b/Kernel/FileSystem/ProcFS.cpp
index e197fd1c92..f1cc2c74aa 100644
--- a/Kernel/FileSystem/ProcFS.cpp
+++ b/Kernel/FileSystem/ProcFS.cpp
@@ -189,10 +189,10 @@ ByteBuffer procfs$pid_fds(InodeIdentifier identifier)
         return {};
     StringBuilder builder;
     for (int i = 0; i < process.max_open_file_descriptors(); ++i) {
-        auto* descriptor = process.file_description(i);
-        if (!descriptor)
+        auto* description = process.file_description(i);
+        if (!description)
             continue;
-        builder.appendf("% 3u %s\n", i, descriptor->absolute_path().characters());
+        builder.appendf("% 3u %s\n", i, description->absolute_path().characters());
     }
     return builder.to_byte_buffer();
 }
@@ -204,10 +204,10 @@ ByteBuffer procfs$pid_fd_entry(InodeIdentifier identifier)
         return {};
     auto& process = handle->process();
     int fd = to_fd(identifier);
-    auto* descriptor = process.file_description(fd);
-    if (!descriptor)
+    auto* description = process.file_description(fd);
+    if (!description)
         return {};
-    return descriptor->absolute_path().to_byte_buffer();
+    return description->absolute_path().to_byte_buffer();
 }
 
 ByteBuffer procfs$pid_vm(InodeIdentifier identifier)
@@ -831,7 +831,7 @@ InodeMetadata ProcFSInode::metadata() const
     return metadata;
 }
 
-ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* descriptor) const
+ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* description) const
 {
 #ifdef PROCFS_DEBUG
     dbgprintf("ProcFS: read_bytes %u\n", index());
@@ -855,19 +855,19 @@ ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
     ASSERT(read_callback);
 
     ByteBuffer generated_data;
-    if (!descriptor) {
+    if (!description) {
         generated_data = (*read_callback)(identifier());
     } else {
-        if (!descriptor->generator_cache())
-            descriptor->generator_cache() = (*read_callback)(identifier());
-        generated_data = descriptor->generator_cache();
+        if (!description->generator_cache())
+            description->generator_cache() = (*read_callback)(identifier());
+        generated_data = description->generator_cache();
     }
 
     auto& data = generated_data;
     ssize_t nread = min(static_cast<off_t>(data.size() - offset), static_cast<off_t>(count));
     memcpy(buffer, data.pointer() + offset, nread);
-    if (nread == 0 && descriptor && descriptor->generator_cache())
-        descriptor->generator_cache().clear();
+    if (nread == 0 && description && description->generator_cache())
+        description->generator_cache().clear();
     return nread;
 }
 
@@ -936,8 +936,8 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
             return false;
         auto& process = handle->process();
         for (int i = 0; i < process.max_open_file_descriptors(); ++i) {
-            auto* descriptor = process.file_description(i);
-            if (!descriptor)
+            auto* description = process.file_description(i);
+            if (!description)
                 continue;
             char name[16];
             int name_length = ksprintf(name, "%u", i);
diff --git a/Kernel/FileSystem/SyntheticFileSystem.cpp b/Kernel/FileSystem/SyntheticFileSystem.cpp
index df2b50bc4e..62ea9c55fd 100644
--- a/Kernel/FileSystem/SyntheticFileSystem.cpp
+++ b/Kernel/FileSystem/SyntheticFileSystem.cpp
@@ -185,7 +185,7 @@ InodeMetadata SynthFSInode::metadata() const
     return m_metadata;
 }
 
-ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* descriptor) const
+ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* description) const
 {
     LOCKER(m_lock);
 #ifdef SYNTHFS_DEBUG
@@ -196,20 +196,20 @@ ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, File
 
     ByteBuffer generated_data;
     if (m_generator) {
-        if (!descriptor) {
+        if (!description) {
             generated_data = m_generator(const_cast<SynthFSInode&>(*this));
         } else {
-            if (!descriptor->generator_cache())
-                descriptor->generator_cache() = m_generator(const_cast<SynthFSInode&>(*this));
-            generated_data = descriptor->generator_cache();
+            if (!description->generator_cache())
+                description->generator_cache() = m_generator(const_cast<SynthFSInode&>(*this));
+            generated_data = description->generator_cache();
         }
     }
 
     auto* data = generated_data ? &generated_data : &m_data;
     ssize_t nread = min(static_cast<off_t>(data->size() - offset), static_cast<off_t>(count));
     memcpy(buffer, data->pointer() + offset, nread);
-    if (nread == 0 && descriptor && descriptor->generator_cache())
-        descriptor->generator_cache().clear();
+    if (nread == 0 && description && description->generator_cache())
+        description->generator_cache().clear();
     return nread;
 }
 
diff --git a/Kernel/KSyms.cpp b/Kernel/KSyms.cpp
index 94be09f56a..9e0eddc458 100644
--- a/Kernel/KSyms.cpp
+++ b/Kernel/KSyms.cpp
@@ -157,8 +157,8 @@ void load_ksyms()
 {
     auto result = VFS::the().open("/kernel.map", 0, 0, VFS::the().root_custody());
     ASSERT(!result.is_error());
-    auto descriptor = result.value();
-    auto buffer = descriptor->read_entire_file();
+    auto description = result.value();
+    auto buffer = description->read_entire_file();
     ASSERT(buffer);
     load_ksyms_from_data(buffer);
 }
diff --git a/Kernel/Net/IPv4Socket.cpp b/Kernel/Net/IPv4Socket.cpp
index 916abc74d8..0b205b191a 100644
--- a/Kernel/Net/IPv4Socket.cpp
+++ b/Kernel/Net/IPv4Socket.cpp
@@ -89,7 +89,7 @@ KResult IPv4Socket::bind(const sockaddr* address, socklen_t address_size)
     return protocol_bind();
 }
 
-KResult IPv4Socket::connect(FileDescription& descriptor, const sockaddr* address, socklen_t address_size, ShouldBlock should_block)
+KResult IPv4Socket::connect(FileDescription& description, const sockaddr* address, socklen_t address_size, ShouldBlock should_block)
 {
     ASSERT(!m_bound);
     if (address_size != sizeof(sockaddr_in))
@@ -101,7 +101,7 @@ KResult IPv4Socket::connect(FileDescription& descriptor, const sockaddr* address
     m_peer_address = IPv4Address((const byte*)&ia.sin_addr.s_addr);
     m_peer_port = ntohs(ia.sin_port);
 
-    return protocol_connect(descriptor, should_block);
+    return protocol_connect(description, should_block);
 }
 
 void IPv4Socket::attach(FileDescription&)
@@ -114,23 +114,23 @@ void IPv4Socket::detach(FileDescription&)
     --m_attached_fds;
 }
 
-bool IPv4Socket::can_read(FileDescription& descriptor) const
+bool IPv4Socket::can_read(FileDescription& description) const
 {
-    if (descriptor.socket_role() == SocketRole::Listener)
+    if (description.socket_role() == SocketRole::Listener)
         return can_accept();
     if (protocol_is_disconnected())
         return true;
     return m_can_read;
 }
 
-ssize_t IPv4Socket::read(FileDescription& descriptor, byte* buffer, ssize_t size)
+ssize_t IPv4Socket::read(FileDescription& description, byte* buffer, ssize_t size)
 {
-    return recvfrom(descriptor, buffer, size, 0, nullptr, 0);
+    return recvfrom(description, buffer, size, 0, nullptr, 0);
 }
 
-ssize_t IPv4Socket::write(FileDescription& descriptor, const byte* data, ssize_t size)
+ssize_t IPv4Socket::write(FileDescription& description, const byte* data, ssize_t size)
 {
-    return sendto(descriptor, data, size, 0, nullptr, 0);
+    return sendto(description, data, size, 0, nullptr, 0);
 }
 
 bool IPv4Socket::can_write(FileDescription&) const
@@ -184,7 +184,7 @@ ssize_t IPv4Socket::sendto(FileDescription&, const void* data, size_t data_lengt
     return protocol_send(data, data_length);
 }
 
-ssize_t IPv4Socket::recvfrom(FileDescription& descriptor, void* buffer, size_t buffer_length, int flags, sockaddr* addr, socklen_t* addr_length)
+ssize_t IPv4Socket::recvfrom(FileDescription& description, void* buffer, size_t buffer_length, int flags, sockaddr* addr, socklen_t* addr_length)
 {
     (void)flags;
     if (addr_length && *addr_length < sizeof(sockaddr_in))
@@ -212,7 +212,7 @@ ssize_t IPv4Socket::recvfrom(FileDescription& descriptor, void* buffer, size_t b
         }
 
         load_receive_deadline();
-        current->block(Thread::BlockedReceive, descriptor);
+        current->block(Thread::BlockedReceive, description);
 
         LOCKER(lock());
         if (!m_can_read) {
diff --git a/Kernel/Net/LocalSocket.cpp b/Kernel/Net/LocalSocket.cpp
index 0097e71db4..95fcc6b940 100644
--- a/Kernel/Net/LocalSocket.cpp
+++ b/Kernel/Net/LocalSocket.cpp
@@ -71,7 +71,7 @@ KResult LocalSocket::bind(const sockaddr* address, socklen_t address_size)
     return KSuccess;
 }
 
-KResult LocalSocket::connect(FileDescription& descriptor, const sockaddr* address, socklen_t address_size, ShouldBlock)
+KResult LocalSocket::connect(FileDescription& description, const sockaddr* address, socklen_t address_size, ShouldBlock)
 {
     ASSERT(!m_bound);
     if (address_size != sizeof(sockaddr_un))
@@ -87,10 +87,10 @@ KResult LocalSocket::connect(FileDescription& descriptor, const sockaddr* addres
     kprintf("%s(%u) LocalSocket{%p} connect(%s)\n", current->process().name().characters(), current->pid(), this, safe_address);
 #endif
 
-    auto descriptor_or_error = VFS::the().open(safe_address, 0, 0, current->process().current_directory());
-    if (descriptor_or_error.is_error())
+    auto description_or_error = VFS::the().open(safe_address, 0, 0, current->process().current_directory());
+    if (description_or_error.is_error())
         return KResult(-ECONNREFUSED);
-    m_file = move(descriptor_or_error.value());
+    m_file = move(description_or_error.value());
 
     ASSERT(m_file->inode());
     if (!m_file->inode()->socket())
@@ -103,12 +103,12 @@ KResult LocalSocket::connect(FileDescription& descriptor, const sockaddr* addres
     if (result.is_error())
         return result;
 
-    return current->wait_for_connect(descriptor);
+    return current->wait_for_connect(description);
 }
 
-void LocalSocket::attach(FileDescription& descriptor)
+void LocalSocket::attach(FileDescription& description)
 {
-    switch (descriptor.socket_role()) {
+    switch (description.socket_role()) {
     case SocketRole::Accepted:
         ++m_accepted_fds_open;
         break;
@@ -123,9 +123,9 @@ void LocalSocket::attach(FileDescription& descriptor)
     }
 }
 
-void LocalSocket::detach(FileDescription& descriptor)
+void LocalSocket::detach(FileDescription& description)
 {
-    switch (descriptor.socket_role()) {
+    switch (description.socket_role()) {
     case SocketRole::Accepted:
         ASSERT(m_accepted_fds_open);
         --m_accepted_fds_open;
@@ -143,30 +143,30 @@ void LocalSocket::detach(FileDescription& descriptor)
     }
 }
 
-bool LocalSocket::can_read(FileDescription& descriptor) const
+bool LocalSocket::can_read(FileDescription& description) const
 {
-    auto role = descriptor.socket_role();
+    auto role = description.socket_role();
     if (role == SocketRole::Listener)
         return can_accept();
     if (role == SocketRole::Accepted)
-        return !has_attached_peer(descriptor) || !m_for_server.is_empty();
+        return !has_attached_peer(description) || !m_for_server.is_empty();
     if (role == SocketRole::Connected)
-        return !has_attached_peer(descriptor) || !m_for_client.is_empty();
+        return !has_attached_peer(description) || !m_for_client.is_empty();
     ASSERT_NOT_REACHED();
 }
 
-ssize_t LocalSocket::read(FileDescription& descriptor, byte* buffer, ssize_t size)
+ssize_t LocalSocket::read(FileDescription& description, byte* buffer, ssize_t size)
 {
-    auto role = descriptor.socket_role();
+    auto role = description.socket_role();
     if (role == SocketRole::Accepted) {
-        if (!descriptor.is_blocking()) {
+        if (!description.is_blocking()) {
             if (m_for_server.is_empty())
                 return -EAGAIN;
         }
         return m_for_server.read(buffer, size);
     }
     if (role == SocketRole::Connected) {
-        if (!descriptor.is_blocking()) {
+        if (!description.is_blocking()) {
             if (m_for_client.is_empty())
                 return -EAGAIN;
         }
@@ -175,41 +175,41 @@ ssize_t LocalSocket::read(FileDescription& descriptor, byte* buffer, ssize_t siz
     ASSERT_NOT_REACHED();
 }
 
-bool LocalSocket::has_attached_peer(const FileDescription& descriptor) const
+bool LocalSocket::has_attached_peer(const FileDescription& description) const
 {
-    if (descriptor.socket_role() == SocketRole::Accepted)
+    if (description.socket_role() == SocketRole::Accepted)
         return m_connected_fds_open || m_connecting_fds_open;
-    if (descriptor.socket_role() == SocketRole::Connected)
+    if (description.socket_role() == SocketRole::Connected)
         return m_accepted_fds_open;
     ASSERT_NOT_REACHED();
 }
 
-ssize_t LocalSocket::write(FileDescription& descriptor, const byte* data, ssize_t size)
+ssize_t LocalSocket::write(FileDescription& description, const byte* data, ssize_t size)
 {
-    if (!has_attached_peer(descriptor))
+    if (!has_attached_peer(description))
         return -EPIPE;
-    if (descriptor.socket_role() == SocketRole::Accepted)
+    if (description.socket_role() == SocketRole::Accepted)
         return m_for_client.write(data, size);
-    if (descriptor.socket_role() == SocketRole::Connected)
+    if (description.socket_role() == SocketRole::Connected)
         return m_for_server.write(data, size);
     ASSERT_NOT_REACHED();
 }
 
-bool LocalSocket::can_write(FileDescription& descriptor) const
+bool LocalSocket::can_write(FileDescription& description) const
 {
-    if (descriptor.socket_role() == SocketRole::Accepted)
-        return !has_attached_peer(descriptor) || m_for_client.bytes_in_write_buffer() < 16384;
-    if (descriptor.socket_role() == SocketRole::Connected)
-        return !has_attached_peer(descriptor) || m_for_server.bytes_in_write_buffer() < 16384;
+    if (description.socket_role() == SocketRole::Accepted)
+        return !has_attached_peer(description) || m_for_client.bytes_in_write_buffer() < 16384;
+    if (description.socket_role() == SocketRole::Connected)
+        return !has_attached_peer(description) || m_for_server.bytes_in_write_buffer() < 16384;
     ASSERT_NOT_REACHED();
 }
 
-ssize_t LocalSocket::sendto(FileDescription& descriptor, const void* data, size_t data_size, int, const sockaddr*, socklen_t)
+ssize_t LocalSocket::sendto(FileDescription& description, const void* data, size_t data_size, int, const sockaddr*, socklen_t)
 {
-    return write(descriptor, (const byte*)data, data_size);
+    return write(description, (const byte*)data, data_size);
 }
 
-ssize_t LocalSocket::recvfrom(FileDescription& descriptor, void* buffer, size_t buffer_size, int, sockaddr*, socklen_t*)
+ssize_t LocalSocket::recvfrom(FileDescription& description, void* buffer, size_t buffer_size, int, sockaddr*, socklen_t*)
 {
-    return read(descriptor, (byte*)buffer, buffer_size);
+    return read(description, (byte*)buffer, buffer_size);
 }
diff --git a/Kernel/Net/Socket.cpp b/Kernel/Net/Socket.cpp
index 149a9442e0..6164cbe783 100644
--- a/Kernel/Net/Socket.cpp
+++ b/Kernel/Net/Socket.cpp
@@ -142,7 +142,7 @@ static const char* to_string(SocketRole role)
     }
 }
 
-String Socket::absolute_path(const FileDescription& descriptor) const
+String Socket::absolute_path(const FileDescription& description) const
 {
-    return String::format("socket:%x (role: %s)", this, to_string(descriptor.socket_role()));
+    return String::format("socket:%x (role: %s)", this, to_string(description.socket_role()));
 }
diff --git a/Kernel/Net/TCPSocket.cpp b/Kernel/Net/TCPSocket.cpp
index b0570c402d..c38f3c3cd6 100644
--- a/Kernel/Net/TCPSocket.cpp
+++ b/Kernel/Net/TCPSocket.cpp
@@ -147,7 +147,7 @@ NetworkOrdered<word> TCPSocket::compute_tcp_checksum(const IPv4Address& source,
     return ~(checksum & 0xffff);
 }
 
-KResult TCPSocket::protocol_connect(FileDescription& descriptor, ShouldBlock should_block)
+KResult TCPSocket::protocol_connect(FileDescription& description, ShouldBlock should_block)
 {
     auto* adapter = adapter_for_route_to(peer_address());
     if (!adapter)
@@ -162,7 +162,7 @@ KResult TCPSocket::protocol_connect(FileDescription& descriptor, ShouldBlock sho
     m_state = State::Connecting;
 
     if (should_block == ShouldBlock::Yes) {
-        current->block(Thread::BlockedConnect, descriptor);
+        current->block(Thread::BlockedConnect, description);
         ASSERT(is_connected());
         return KSuccess;
     }
diff --git a/Kernel/Process.cpp b/Kernel/Process.cpp
index 7963f3f6df..f388e42251 100644
--- a/Kernel/Process.cpp
+++ b/Kernel/Process.cpp
@@ -190,10 +190,10 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
     }
     if (offset & ~PAGE_MASK)
         return (void*)-EINVAL;
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return (void*)-EBADF;
-    auto region_or_error = descriptor->mmap(*this, VirtualAddress((dword)addr), offset, size, prot);
+    auto region_or_error = description->mmap(*this, VirtualAddress((dword)addr), offset, size, prot);
     if (region_or_error.is_error())
         return (void*)(int)region_or_error.error();
     auto region = region_or_error.value();
@@ -314,8 +314,8 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
     auto result = VFS::the().open(path, 0, 0, current_directory());
     if (result.is_error())
         return result.error();
-    auto descriptor = result.value();
-    auto metadata = descriptor->metadata();
+    auto description = result.value();
+    auto metadata = description->metadata();
 
     if (!metadata.may_execute(m_euid, m_gids))
         return -EACCES;
@@ -332,8 +332,8 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
 #endif
     ProcessPagingScope paging_scope(*this);
 
-    auto vmo = VMObject::create_file_backed(descriptor->inode());
-    vmo->set_name(descriptor->absolute_path());
+    auto vmo = VMObject::create_file_backed(description->inode());
+    vmo->set_name(description->absolute_path());
     RetainPtr<Region> region = allocate_region_with_vmo(VirtualAddress(), metadata.size, vmo.copy_ref(), 0, vmo->name(), PROT_READ);
     ASSERT(region);
 
@@ -388,7 +388,7 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
     }
 
     m_elf_loader = move(loader);
-    m_executable = descriptor->custody();
+    m_executable = description->custody();
 
     if (metadata.is_setuid())
         m_euid = metadata.uid;
@@ -403,8 +403,8 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
 
     for (int i = 0; i < m_fds.size(); ++i) {
         auto& daf = m_fds[i];
-        if (daf.descriptor && daf.flags & FD_CLOEXEC) {
-            daf.descriptor->close();
+        if (daf.description && daf.flags & FD_CLOEXEC) {
+            daf.description->close();
             daf = {};
         }
     }
@@ -605,12 +605,12 @@ Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring
     if (fork_parent) {
         m_fds.resize(fork_parent->m_fds.size());
         for (int i = 0; i < fork_parent->m_fds.size(); ++i) {
-            if (!fork_parent->m_fds[i].descriptor)
+            if (!fork_parent->m_fds[i].description)
                 continue;
 #ifdef FORK_DEBUG
-            dbgprintf("fork: cloning fd %u... (%p) istty? %u\n", i, fork_parent->m_fds[i].descriptor.ptr(), fork_parent->m_fds[i].descriptor->is_tty());
+            dbgprintf("fork: cloning fd %u... (%p) istty? %u\n", i, fork_parent->m_fds[i].description.ptr(), fork_parent->m_fds[i].description->is_tty());
 #endif
-            m_fds[i].descriptor = fork_parent->m_fds[i].descriptor->clone();
+            m_fds[i].description = fork_parent->m_fds[i].description->clone();
             m_fds[i].flags = fork_parent->m_fds[i].flags;
         }
     } else {
@@ -769,7 +769,7 @@ FileDescription* Process::file_description(int fd)
     if (fd < 0)
         return nullptr;
     if (fd < m_fds.size())
-        return m_fds[fd].descriptor.ptr();
+        return m_fds[fd].description.ptr();
     return nullptr;
 }
 
@@ -778,7 +778,7 @@ const FileDescription* Process::file_description(int fd) const
     if (fd < 0)
         return nullptr;
     if (fd < m_fds.size())
-        return m_fds[fd].descriptor.ptr();
+        return m_fds[fd].description.ptr();
     return nullptr;
 }
 
@@ -788,18 +788,18 @@ ssize_t Process::sys$get_dir_entries(int fd, void* buffer, ssize_t size)
         return -EINVAL;
     if (!validate_write(buffer, size))
         return -EFAULT;
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    return descriptor->get_dir_entries((byte*)buffer, size);
+    return description->get_dir_entries((byte*)buffer, size);
 }
 
 int Process::sys$lseek(int fd, off_t offset, int whence)
 {
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    return descriptor->seek(offset, whence);
+    return description->seek(offset, whence);
 }
 
 int Process::sys$ttyname_r(int fd, char* buffer, ssize_t size)
@@ -808,12 +808,12 @@ int Process::sys$ttyname_r(int fd, char* buffer, ssize_t size)
         return -EINVAL;
     if (!validate_write(buffer, size))
         return -EFAULT;
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_tty())
+    if (!description->is_tty())
         return -ENOTTY;
-    auto tty_name = descriptor->tty()->tty_name();
+    auto tty_name = description->tty()->tty_name();
     if (size < tty_name.length() + 1)
         return -ERANGE;
     strcpy(buffer, tty_name.characters());
@@ -826,10 +826,10 @@ int Process::sys$ptsname_r(int fd, char* buffer, ssize_t size)
         return -EINVAL;
     if (!validate_write(buffer, size))
         return -EFAULT;
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    auto* master_pty = descriptor->master_pty();
+    auto* master_pty = description->master_pty();
     if (!master_pty)
         return -ENOTTY;
     auto pts_name = master_pty->pts_name();
@@ -849,13 +849,13 @@ ssize_t Process::sys$writev(int fd, const struct iovec* iov, int iov_count)
 
     // FIXME: Return EINVAL if sum of iovecs is greater than INT_MAX
 
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
 
     int nwritten = 0;
     for (int i = 0; i < iov_count; ++i) {
-        int rc = do_write(*descriptor, (const byte*)iov[i].iov_base, iov[i].iov_len);
+        int rc = do_write(*description, (const byte*)iov[i].iov_base, iov[i].iov_len);
         if (rc < 0) {
             if (nwritten == 0)
                 return rc;
@@ -873,32 +873,32 @@ ssize_t Process::sys$writev(int fd, const struct iovec* iov, int iov_count)
     return nwritten;
 }
 
-ssize_t Process::do_write(FileDescription& descriptor, const byte* data, int data_size)
+ssize_t Process::do_write(FileDescription& description, const byte* data, int data_size)
 {
     ssize_t nwritten = 0;
-    if (!descriptor.is_blocking()) {
-        if (!descriptor.can_write())
+    if (!description.is_blocking()) {
+        if (!description.can_write())
             return -EAGAIN;
     }
 
-    if (descriptor.should_append()) {
+    if (description.should_append()) {
 #ifdef IO_DEBUG
         dbgprintf("seeking to end (O_APPEND)\n");
 #endif
-        descriptor.seek(0, SEEK_END);
+        description.seek(0, SEEK_END);
     }
 
     while (nwritten < data_size) {
 #ifdef IO_DEBUG
         dbgprintf("while %u < %u\n", nwritten, size);
 #endif
-        if (!descriptor.can_write()) {
+        if (!description.can_write()) {
 #ifdef IO_DEBUG
             dbgprintf("block write on %d\n", fd);
 #endif
-            current->block(Thread::State::BlockedWrite, descriptor);
+            current->block(Thread::State::BlockedWrite, description);
         }
-        ssize_t rc = descriptor.write(data + nwritten, data_size - nwritten);
+        ssize_t rc = description.write(data + nwritten, data_size - nwritten);
 #ifdef IO_DEBUG
         dbgprintf("   -> write returned %d\n", rc);
 #endif
@@ -930,10 +930,10 @@ ssize_t Process::sys$write(int fd, const byte* data, ssize_t size)
 #ifdef DEBUG_IO
     dbgprintf("%s(%u): sys$write(%d, %p, %u)\n", name().characters(), pid(), fd, data, size);
 #endif
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    auto nwritten = do_write(*descriptor, data, size);
+    auto nwritten = do_write(*description, data, size);
     if (current->has_unmasked_pending_signals()) {
         current->block(Thread::State::BlockedSignal);
         if (nwritten == 0)
@@ -953,25 +953,25 @@ ssize_t Process::sys$read(int fd, byte* buffer, ssize_t size)
 #ifdef DEBUG_IO
     dbgprintf("%s(%u) sys$read(%d, %p, %u)\n", name().characters(), pid(), fd, buffer, size);
 #endif
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    if (descriptor->is_blocking()) {
-        if (!descriptor->can_read()) {
-            current->block(Thread::State::BlockedRead, *descriptor);
+    if (description->is_blocking()) {
+        if (!description->can_read()) {
+            current->block(Thread::State::BlockedRead, *description);
             if (current->m_was_interrupted_while_blocked)
                 return -EINTR;
         }
     }
-    return descriptor->read(buffer, size);
+    return description->read(buffer, size);
 }
 
 int Process::sys$close(int fd)
 {
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    int rc = descriptor->close();
+    int rc = description->close();
     m_fds[fd] = {};
     return rc;
 }
@@ -1008,8 +1008,8 @@ int Process::sys$fcntl(int fd, int cmd, dword arg)
     (void)cmd;
     (void)arg;
     dbgprintf("sys$fcntl: fd=%d, cmd=%d, arg=%u\n", fd, cmd, arg);
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
     // NOTE: The FD flags are not shared between FileDescription objects.
     //       This means that dup() doesn't copy the FD_CLOEXEC flag!
@@ -1021,7 +1021,7 @@ int Process::sys$fcntl(int fd, int cmd, dword arg)
         int new_fd = alloc_fd(arg_fd);
         if (new_fd < 0)
             return new_fd;
-        m_fds[new_fd].set(*descriptor);
+        m_fds[new_fd].set(*description);
         break;
     }
     case F_GETFD:
@@ -1030,9 +1030,9 @@ int Process::sys$fcntl(int fd, int cmd, dword arg)
         m_fds[fd].flags = arg;
         break;
     case F_GETFL:
-        return descriptor->file_flags();
+        return description->file_flags();
     case F_SETFL:
-        descriptor->set_file_flags(arg);
+        description->set_file_flags(arg);
         break;
     default:
         ASSERT_NOT_REACHED();
@@ -1044,10 +1044,10 @@ int Process::sys$fstat(int fd, stat* statbuf)
 {
     if (!validate_write_typed(statbuf))
         return -EFAULT;
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    return descriptor->fstat(*statbuf);
+    return description->fstat(*statbuf);
 }
 
 int Process::sys$lstat(const char* path, stat* statbuf)
@@ -1076,12 +1076,12 @@ int Process::sys$readlink(const char* path, char* buffer, ssize_t size)
     auto result = VFS::the().open(path, O_RDONLY | O_NOFOLLOW_NOERROR, 0, current_directory());
     if (result.is_error())
         return result.error();
-    auto descriptor = result.value();
+    auto description = result.value();
 
-    if (!descriptor->metadata().is_symlink())
+    if (!description->metadata().is_symlink())
         return -EINVAL;
 
-    auto contents = descriptor->read_entire_file();
+    auto contents = description->read_entire_file();
     if (!contents)
         return -EIO; // FIXME: Get a more detailed error from VFS.
 
@@ -1118,8 +1118,8 @@ int Process::sys$getcwd(char* buffer, ssize_t size)
 int Process::number_of_open_file_descriptors() const
 {
     int count = 0;
-    for (auto& descriptor : m_fds) {
-        if (descriptor)
+    for (auto& description : m_fds) {
+        if (description)
             ++count;
     }
     return count;
@@ -1138,12 +1138,12 @@ int Process::sys$open(const char* path, int options, mode_t mode)
     auto result = VFS::the().open(path, options, mode & ~umask(), current_directory());
     if (result.is_error())
         return result.error();
-    auto descriptor = result.value();
-    if (options & O_DIRECTORY && !descriptor->is_directory())
+    auto description = result.value();
+    if (options & O_DIRECTORY && !description->is_directory())
         return -ENOTDIR; // FIXME: This should be handled by VFS::open.
-    descriptor->set_file_flags(options);
+    description->set_file_flags(options);
     dword fd_flags = (options & O_CLOEXEC) ? FD_CLOEXEC : 0;
-    m_fds[fd].set(move(descriptor), fd_flags);
+    m_fds[fd].set(move(description), fd_flags);
     return fd;
 }
 
@@ -1233,10 +1233,10 @@ int Process::sys$uname(utsname* buf)
 
 int Process::sys$isatty(int fd)
 {
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_tty())
+    if (!description->is_tty())
         return -ENOTTY;
     return 1;
 }
@@ -1613,10 +1613,10 @@ int Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
 
 int Process::sys$ioctl(int fd, unsigned request, unsigned arg)
 {
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    return descriptor->file().ioctl(*descriptor, request, arg);
+    return description->file().ioctl(*description, request, arg);
 }
 
 int Process::sys$getdtablesize()
@@ -1626,24 +1626,24 @@ int Process::sys$getdtablesize()
 
 int Process::sys$dup(int old_fd)
 {
-    auto* descriptor = file_description(old_fd);
-    if (!descriptor)
+    auto* description = file_description(old_fd);
+    if (!description)
         return -EBADF;
     int new_fd = alloc_fd(0);
     if (new_fd < 0)
         return new_fd;
-    m_fds[new_fd].set(*descriptor);
+    m_fds[new_fd].set(*description);
     return new_fd;
 }
 
 int Process::sys$dup2(int old_fd, int new_fd)
 {
-    auto* descriptor = file_description(old_fd);
-    if (!descriptor)
+    auto* description = file_description(old_fd);
+    if (!description)
         return -EBADF;
     if (new_fd < 0 || new_fd >= m_max_open_file_descriptors)
         return -EINVAL;
-    m_fds[new_fd].set(*descriptor);
+    m_fds[new_fd].set(*description);
     return new_fd;
 }
 
@@ -1812,14 +1812,14 @@ int Process::sys$select(const Syscall::SC_select_params* params)
             return;
         FD_ZERO(fds);
         for (int fd : vector) {
-            if (auto* descriptor = file_description(fd); descriptor && should_mark(*descriptor)) {
+            if (auto* description = file_description(fd); description && should_mark(*description)) {
                 FD_SET(fd, fds);
                 ++marked_fd_count;
             }
         }
     };
-    mark_fds(params->readfds, current->m_select_read_fds, [](auto& descriptor) { return descriptor.can_read(); });
-    mark_fds(params->writefds, current->m_select_write_fds, [](auto& descriptor) { return descriptor.can_write(); });
+    mark_fds(params->readfds, current->m_select_read_fds, [](auto& description) { return description.can_read(); });
+    mark_fds(params->writefds, current->m_select_write_fds, [](auto& description) { return description.can_write(); });
     // FIXME: We should also mark params->exceptfds as appropriate.
     return marked_fd_count;
 }
@@ -1864,15 +1864,15 @@ int Process::sys$poll(pollfd* fds, int nfds, int timeout)
     int fds_with_revents = 0;
 
     for (int i = 0; i < nfds; ++i) {
-        auto* descriptor = file_description(fds[i].fd);
-        if (!descriptor) {
+        auto* description = file_description(fds[i].fd);
+        if (!description) {
             fds[i].revents = POLLNVAL;
             continue;
         }
         fds[i].revents = 0;
-        if (fds[i].events & POLLIN && descriptor->can_read())
+        if (fds[i].events & POLLIN && description->can_read())
             fds[i].revents |= POLLIN;
-        if (fds[i].events & POLLOUT && descriptor->can_write())
+        if (fds[i].events & POLLOUT && description->can_write())
             fds[i].revents |= POLLOUT;
 
         if (fds[i].revents)
@@ -1940,18 +1940,18 @@ int Process::sys$chmod(const char* pathname, mode_t mode)
 
 int Process::sys$fchmod(int fd, mode_t mode)
 {
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    return descriptor->fchmod(mode);
+    return description->fchmod(mode);
 }
 
 int Process::sys$fchown(int fd, uid_t uid, gid_t gid)
 {
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
-    return descriptor->chown(uid, gid);
+    return description->chown(uid, gid);
 }
 
 int Process::sys$chown(const char* pathname, uid_t uid, gid_t gid)
@@ -2047,13 +2047,13 @@ int Process::sys$socket(int domain, int type, int protocol)
     auto result = Socket::create(domain, type, protocol);
     if (result.is_error())
         return result.error();
-    auto descriptor = FileDescription::create(*result.value());
+    auto description = FileDescription::create(*result.value());
     unsigned flags = 0;
     if (type & SOCK_CLOEXEC)
         flags |= FD_CLOEXEC;
     if (type & SOCK_NONBLOCK)
-        descriptor->set_blocking(false);
-    m_fds[fd].set(move(descriptor), flags);
+        description->set_blocking(false);
+    m_fds[fd].set(move(description), flags);
     return fd;
 }
 
@@ -2061,27 +2061,27 @@ int Process::sys$bind(int sockfd, const sockaddr* address, socklen_t address_len
 {
     if (!validate_read(address, address_length))
         return -EFAULT;
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
     return socket.bind(address, address_length);
 }
 
 int Process::sys$listen(int sockfd, int backlog)
 {
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
     auto result = socket.listen(backlog);
     if (result.is_error())
         return result;
-    descriptor->set_socket_role(SocketRole::Listener);
+    description->set_socket_role(SocketRole::Listener);
     return 0;
 }
 
@@ -2094,25 +2094,25 @@ int Process::sys$accept(int accepting_socket_fd, sockaddr* address, socklen_t* a
     int accepted_socket_fd = alloc_fd();
     if (accepted_socket_fd < 0)
         return accepted_socket_fd;
-    auto* accepting_socket_descriptor = file_description(accepting_socket_fd);
-    if (!accepting_socket_descriptor)
+    auto* accepting_socket_description = file_description(accepting_socket_fd);
+    if (!accepting_socket_description)
         return -EBADF;
-    if (!accepting_socket_descriptor->is_socket())
+    if (!accepting_socket_description->is_socket())
         return -ENOTSOCK;
-    auto& socket = *accepting_socket_descriptor->socket();
+    auto& socket = *accepting_socket_description->socket();
     if (!socket.can_accept()) {
-        ASSERT(!accepting_socket_descriptor->is_blocking());
+        ASSERT(!accepting_socket_description->is_blocking());
         return -EAGAIN;
     }
     auto accepted_socket = socket.accept();
     ASSERT(accepted_socket);
     bool success = accepted_socket->get_local_address(address, address_size);
     ASSERT(success);
-    auto accepted_socket_descriptor = FileDescription::create(move(accepted_socket), SocketRole::Accepted);
+    auto accepted_socket_description = FileDescription::create(move(accepted_socket), SocketRole::Accepted);
     // NOTE: The accepted socket inherits fd flags from the accepting socket.
     //       I'm not sure if this matches other systems but it makes sense to me.
-    accepted_socket_descriptor->set_blocking(accepting_socket_descriptor->is_blocking());
-    m_fds[accepted_socket_fd].set(move(accepted_socket_descriptor), m_fds[accepting_socket_fd].flags);
+    accepted_socket_description->set_blocking(accepting_socket_description->is_blocking());
+    m_fds[accepted_socket_fd].set(move(accepted_socket_description), m_fds[accepting_socket_fd].flags);
     return accepted_socket_fd;
 }
 
@@ -2123,21 +2123,21 @@ int Process::sys$connect(int sockfd, const sockaddr* address, socklen_t address_
     int fd = alloc_fd();
     if (fd < 0)
         return fd;
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
-    if (descriptor->socket_role() == SocketRole::Connected)
+    if (description->socket_role() == SocketRole::Connected)
         return -EISCONN;
-    auto& socket = *descriptor->socket();
-    descriptor->set_socket_role(SocketRole::Connecting);
-    auto result = socket.connect(*descriptor, address, address_size, descriptor->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No);
+    auto& socket = *description->socket();
+    description->set_socket_role(SocketRole::Connecting);
+    auto result = socket.connect(*description, address, address_size, description->is_blocking() ? ShouldBlock::Yes : ShouldBlock::No);
     if (result.is_error()) {
-        descriptor->set_socket_role(SocketRole::None);
+        description->set_socket_role(SocketRole::None);
         return result;
     }
-    descriptor->set_socket_role(SocketRole::Connected);
+    description->set_socket_role(SocketRole::Connected);
     return 0;
 }
 
@@ -2157,14 +2157,14 @@ ssize_t Process::sys$sendto(const Syscall::SC_sendto_params* params)
         return -EFAULT;
     if (addr && !validate_read(addr, addr_length))
         return -EFAULT;
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
     kprintf("sendto %p (%u), flags=%u, addr: %p (%u)\n", data, data_length, flags, addr, addr_length);
-    return socket.sendto(*descriptor, data, data_length, flags, addr, addr_length);
+    return socket.sendto(*description, data, data_length, flags, addr, addr_length);
 }
 
 ssize_t Process::sys$recvfrom(const Syscall::SC_recvfrom_params* params)
@@ -2189,20 +2189,20 @@ ssize_t Process::sys$recvfrom(const Syscall::SC_recvfrom_params* params)
     } else if (addr) {
         return -EINVAL;
     }
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
 
-    bool original_blocking = descriptor->is_blocking();
+    bool original_blocking = description->is_blocking();
     if (flags & MSG_DONTWAIT)
-        descriptor->set_blocking(false);
+        description->set_blocking(false);
 
-    auto nrecv = socket.recvfrom(*descriptor, buffer, buffer_length, flags, addr, addr_length);
+    auto nrecv = socket.recvfrom(*description, buffer, buffer_length, flags, addr, addr_length);
     if (flags & MSG_DONTWAIT)
-        descriptor->set_blocking(original_blocking);
+        description->set_blocking(original_blocking);
 
     return nrecv;
 }
@@ -2218,14 +2218,14 @@ int Process::sys$getsockname(int sockfd, sockaddr* addr, socklen_t* addrlen)
     if (!validate_write(addr, *addrlen))
         return -EFAULT;
 
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
 
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
 
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
     if (!socket.get_local_address(addr, addrlen))
         return -EINVAL; // FIXME: Should this be another error? I'm not sure.
 
@@ -2243,14 +2243,14 @@ int Process::sys$getpeername(int sockfd, sockaddr* addr, socklen_t* addrlen)
     if (!validate_write(addr, *addrlen))
         return -EFAULT;
 
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
 
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
 
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
 
     if (!socket.is_connected())
         return -ENOTCONN;
@@ -2318,12 +2318,12 @@ int Process::sys$getsockopt(const Syscall::SC_getsockopt_params* params)
         return -EFAULT;
     if (!validate_write(value, *value_size))
         return -EFAULT;
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
     return socket.getsockopt(level, option, value, value_size);
 }
 
@@ -2339,12 +2339,12 @@ int Process::sys$setsockopt(const Syscall::SC_setsockopt_params* params)
 
     if (!validate_read(value, value_size))
         return -EFAULT;
-    auto* descriptor = file_description(sockfd);
-    if (!descriptor)
+    auto* description = file_description(sockfd);
+    if (!description)
         return -EBADF;
-    if (!descriptor->is_socket())
+    if (!description->is_socket())
         return -ENOTSOCK;
-    auto& socket = *descriptor->socket();
+    auto& socket = *description->socket();
     return socket.setsockopt(level, option, value, value_size);
 }
 
@@ -2682,8 +2682,8 @@ int Process::sys$shm_open(const char* name, int flags, mode_t mode)
     auto shm_or_error = SharedMemory::open(String(name), flags, mode);
     if (shm_or_error.is_error())
         return shm_or_error.error();
-    auto descriptor = FileDescription::create(shm_or_error.value().ptr());
-    m_fds[fd].set(move(descriptor), FD_CLOEXEC);
+    auto description = FileDescription::create(shm_or_error.value().ptr());
+    m_fds[fd].set(move(description), FD_CLOEXEC);
     return fd;
 }
 
@@ -2696,11 +2696,11 @@ int Process::sys$shm_unlink(const char* name)
 
 int Process::sys$ftruncate(int fd, off_t length)
 {
-    auto* descriptor = file_description(fd);
-    if (!descriptor)
+    auto* description = file_description(fd);
+    if (!description)
         return -EBADF;
     // FIXME: Check that fd is writable, otherwise EINVAL.
-    return descriptor->truncate(length);
+    return description->truncate(length);
 }
 
 int Process::sys$systrace(pid_t pid)
@@ -2714,8 +2714,8 @@ int Process::sys$systrace(pid_t pid)
     int fd = alloc_fd();
     if (fd < 0)
         return fd;
-    auto descriptor = FileDescription::create(peer->ensure_tracer());
-    m_fds[fd].set(move(descriptor), 0);
+    auto description = FileDescription::create(peer->ensure_tracer());
+    m_fds[fd].set(move(description), 0);
     return fd;
 }
 
@@ -2728,13 +2728,13 @@ ProcessTracer& Process::ensure_tracer()
 
 void Process::FileDescriptionAndFlags::clear()
 {
-    descriptor = nullptr;
+    description = nullptr;
     flags = 0;
 }
 
 void Process::FileDescriptionAndFlags::set(Retained<FileDescription>&& d, dword f)
 {
-    descriptor = move(d);
+    description = move(d);
     flags = f;
 }
 
diff --git a/Kernel/Process.h b/Kernel/Process.h
index 0042ca87c8..90b685d582 100644
--- a/Kernel/Process.h
+++ b/Kernel/Process.h
@@ -305,10 +305,10 @@ private:
     Priority m_priority { NormalPriority };
 
     struct FileDescriptionAndFlags {
-        operator bool() const { return !!descriptor; }
+        operator bool() const { return !!description; }
         void clear();
         void set(Retained<FileDescription>&& d, dword f = 0);
-        RetainPtr<FileDescription> descriptor;
+        RetainPtr<FileDescription> description;
         dword flags { 0 };
     };
     Vector<FileDescriptionAndFlags> m_fds;
diff --git a/Kernel/Scheduler.cpp b/Kernel/Scheduler.cpp
index 8e092b8625..5ddae383a5 100644
--- a/Kernel/Scheduler.cpp
+++ b/Kernel/Scheduler.cpp
@@ -96,34 +96,34 @@ bool Scheduler::pick_next()
         }
 
         if (thread.state() == Thread::BlockedRead) {
-            ASSERT(thread.m_blocked_descriptor);
+            ASSERT(thread.m_blocked_description);
             // FIXME: Block until the amount of data wanted is available.
-            if (thread.m_blocked_descriptor->can_read())
+            if (thread.m_blocked_description->can_read())
                 thread.unblock();
             return IterationDecision::Continue;
         }
 
         if (thread.state() == Thread::BlockedWrite) {
-            ASSERT(thread.m_blocked_descriptor != -1);
-            if (thread.m_blocked_descriptor->can_write())
+            ASSERT(thread.m_blocked_description != -1);
+            if (thread.m_blocked_description->can_write())
                 thread.unblock();
             return IterationDecision::Continue;
         }
 
         if (thread.state() == Thread::BlockedConnect) {
-            auto& descriptor = *thread.m_blocked_descriptor;
-            auto& socket = *descriptor.socket();
+            auto& description = *thread.m_blocked_description;
+            auto& socket = *description.socket();
             if (socket.is_connected())
                 thread.unblock();
             return IterationDecision::Continue;
         }
 
         if (thread.state() == Thread::BlockedReceive) {
-            auto& descriptor = *thread.m_blocked_descriptor;
-            auto& socket = *descriptor.socket();
+            auto& description = *thread.m_blocked_description;
+            auto& socket = *description.socket();
             // FIXME: Block until the amount of data wanted is available.
             bool timed_out = now_sec > socket.receive_deadline().tv_sec || (now_sec == socket.receive_deadline().tv_sec && now_usec >= socket.receive_deadline().tv_usec);
-            if (timed_out || descriptor.can_read()) {
+            if (timed_out || description.can_read()) {
                 thread.unblock();
                 return IterationDecision::Continue;
             }
@@ -138,13 +138,13 @@ bool Scheduler::pick_next()
                 }
             }
             for (int fd : thread.m_select_read_fds) {
-                if (process.m_fds[fd].descriptor->can_read()) {
+                if (process.m_fds[fd].description->can_read()) {
                     thread.unblock();
                     return IterationDecision::Continue;
                 }
             }
             for (int fd : thread.m_select_write_fds) {
-                if (process.m_fds[fd].descriptor->can_write()) {
+                if (process.m_fds[fd].description->can_write()) {
                     thread.unblock();
                     return IterationDecision::Continue;
                 }
diff --git a/Kernel/TTY/MasterPTY.cpp b/Kernel/TTY/MasterPTY.cpp
index b709fe7ebc..b3e64ceda1 100644
--- a/Kernel/TTY/MasterPTY.cpp
+++ b/Kernel/TTY/MasterPTY.cpp
@@ -96,9 +96,9 @@ void MasterPTY::close()
     }
 }
 
-int MasterPTY::ioctl(FileDescription& descriptor, unsigned request, unsigned arg)
+int MasterPTY::ioctl(FileDescription& description, unsigned request, unsigned arg)
 {
     if (request == TIOCSWINSZ)
-        return m_slave->ioctl(descriptor, request, arg);
+        return m_slave->ioctl(description, request, arg);
     return -EINVAL;
 }
diff --git a/Kernel/TTY/SlavePTY.cpp b/Kernel/TTY/SlavePTY.cpp
index 102a7ee48a..2773db17a8 100644
--- a/Kernel/TTY/SlavePTY.cpp
+++ b/Kernel/TTY/SlavePTY.cpp
@@ -46,18 +46,18 @@ bool SlavePTY::can_write(FileDescription&) const
     return m_master->can_write_from_slave();
 }
 
-bool SlavePTY::can_read(FileDescription& descriptor) const
+bool SlavePTY::can_read(FileDescription& description) const
 {
     if (m_master->is_closed())
         return true;
-    return TTY::can_read(descriptor);
+    return TTY::can_read(description);
 }
 
-ssize_t SlavePTY::read(FileDescription& descriptor, byte* buffer, ssize_t size)
+ssize_t SlavePTY::read(FileDescription& description, byte* buffer, ssize_t size)
 {
     if (m_master->is_closed())
         return 0;
-    return TTY::read(descriptor, buffer, size);
+    return TTY::read(description, buffer, size);
 }
 
 void SlavePTY::close()
diff --git a/Kernel/Thread.cpp b/Kernel/Thread.cpp
index 7903f2d9bb..7142a07a42 100644
--- a/Kernel/Thread.cpp
+++ b/Kernel/Thread.cpp
@@ -99,7 +99,7 @@ Thread::~Thread()
 
 void Thread::unblock()
 {
-    m_blocked_descriptor = nullptr;
+    m_blocked_description = nullptr;
     if (current == this) {
         set_state(Thread::Running);
         return;
@@ -129,9 +129,9 @@ void Thread::block(Thread::State new_state)
         process().big_lock().lock();
 }
 
-void Thread::block(Thread::State new_state, FileDescription& descriptor)
+void Thread::block(Thread::State new_state, FileDescription& description)
 {
-    m_blocked_descriptor = &descriptor;
+    m_blocked_description = &description;
     block(new_state);
 }
 
@@ -192,7 +192,7 @@ void Thread::finalize()
     dbgprintf("Finalizing Thread %u in %s(%u)\n", tid(), m_process.name().characters(), pid());
     set_state(Thread::State::Dead);
 
-    m_blocked_descriptor = nullptr;
+    m_blocked_description = nullptr;
 
     if (this == &m_process.main_thread())
         m_process.finalize();
@@ -530,13 +530,13 @@ Thread* Thread::clone(Process& process)
     return clone;
 }
 
-KResult Thread::wait_for_connect(FileDescription& descriptor)
+KResult Thread::wait_for_connect(FileDescription& description)
 {
-    ASSERT(descriptor.is_socket());
-    auto& socket = *descriptor.socket();
+    ASSERT(description.is_socket());
+    auto& socket = *description.socket();
     if (socket.is_connected())
         return KSuccess;
-    block(Thread::State::BlockedConnect, descriptor);
+    block(Thread::State::BlockedConnect, description);
     Scheduler::yield();
     if (!socket.is_connected())
         return KResult(-ECONNREFUSED);
diff --git a/Kernel/Thread.h b/Kernel/Thread.h
index a76d264bca..91cd852e5e 100644
--- a/Kernel/Thread.h
+++ b/Kernel/Thread.h
@@ -179,7 +179,7 @@ private:
     RetainPtr<Region> m_kernel_stack_region;
     RetainPtr<Region> m_kernel_stack_for_signal_handler_region;
     pid_t m_waitee_pid { -1 };
-    RetainPtr<FileDescription> m_blocked_descriptor;
+    RetainPtr<FileDescription> m_blocked_description;
     timeval m_select_timeout;
     SignalActionData m_signal_action_data[32];
     Region* m_signal_stack_user_region { nullptr };