RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-22 16:55:09 +00:00
Code Issues Activity Actions

Kernel: Add bitwise operators for Thread::FileBlocker::BlockFlags enum

Browse source 
Switch to using type-safe bitwise operators for the BlockFlags class,
this cleans up a lot of boilerplate casts which are necessary when the
enum is declared as `enum class`.
This commit is contained in:
Brian Gianforcaro 2021-03-07 03:01:11 -08:00 • committed by Andreas Kling
parent eaef57443c
commit 5f6ab77352
7 changed files with 57 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

23
Kernel/FileSystem/FileDescription.cpp
View file

@ -98,22 +98,23 @@ KResult FileDescription::attach()
Thread::FileBlocker::BlockFlags FileDescription::should_unblock(Thread::FileBlocker::BlockFlags block_flags) const
{
u32 unblock_flags = (u32)Thread::FileBlocker::BlockFlags::None;
if (((u32)block_flags & (u32)Thread::FileBlocker::BlockFlags::Read) && can_read())
unblock_flags |= (u32)Thread::FileBlocker::BlockFlags::Read;
if (((u32)block_flags & (u32)Thread::FileBlocker::BlockFlags::Write) && can_write())
unblock_flags |= (u32)Thread::FileBlocker::BlockFlags::Write;
using BlockFlags = Thread::FileBlocker::BlockFlags;
BlockFlags unblock_flags = BlockFlags::None;
if (has_flag(block_flags, BlockFlags::Read) && can_read())
unblock_flags |= BlockFlags::Read;
if (has_flag(block_flags, BlockFlags::Write) && can_write())
unblock_flags |= BlockFlags::Write;
// TODO: Implement Thread::FileBlocker::BlockFlags::Exception
if ((u32)block_flags & (u32)Thread::FileBlocker::BlockFlags::SocketFlags) {
if (has_flag(block_flags, BlockFlags::SocketFlags)) {
auto* sock = socket();
VERIFY(sock);
if (((u32)block_flags & (u32)Thread::FileBlocker::BlockFlags::Accept) && sock->can_accept())
unblock_flags |= (u32)Thread::FileBlocker::BlockFlags::Accept;
if (((u32)block_flags & (u32)Thread::FileBlocker::BlockFlags::Connect) && sock->setup_state() == Socket::SetupState::Completed)
unblock_flags |= (u32)Thread::FileBlocker::BlockFlags::Connect;
if (has_flag(block_flags, BlockFlags::Accept) && sock->can_accept())
unblock_flags |= BlockFlags::Accept;
if (has_flag(block_flags, BlockFlags::Connect) && sock->setup_state() == Socket::SetupState::Completed)
unblock_flags |= BlockFlags::Connect;
}
return (Thread::FileBlocker::BlockFlags)unblock_flags;
return unblock_flags;
}
KResult FileDescription::stat(::stat& buffer)

10
Kernel/Net/IPv4Socket.cpp
View file

@ -47,6 +47,8 @@ namespace Kernel {
static AK::Singleton<Lockable<HashTable<IPv4Socket*>>> s_table;
using BlockFlags = Thread::FileDescriptionBlocker::BlockFlags;
Lockable<HashTable<IPv4Socket*>>& IPv4Socket::all_sockets()
{
return *s_table;
@ -247,11 +249,11 @@ KResultOr<size_t> IPv4Socket::receive_byte_buffered(FileDescription& description
return EAGAIN;
locker.unlock();
auto unblocked_flags = Thread::FileDescriptionBlocker::BlockFlags::None;
auto unblocked_flags = BlockFlags::None;
auto res = Thread::current()->block<Thread::ReadBlocker>({}, description, unblocked_flags);
locker.lock();
if (!((u32)unblocked_flags & (u32)Thread::FileDescriptionBlocker::BlockFlags::Read)) {
if (!has_flag(unblocked_flags, BlockFlags::Read)) {
if (res.was_interrupted())
return EINTR;
@ -300,11 +302,11 @@ KResultOr<size_t> IPv4Socket::receive_packet_buffered(FileDescription& descripti
}
locker.unlock();
auto unblocked_flags = Thread::FileDescriptionBlocker::BlockFlags::None;
auto unblocked_flags = BlockFlags::None;
auto res = Thread::current()->block<Thread::ReadBlocker>({}, description, unblocked_flags);
locker.lock();
if (!((u32)unblocked_flags & (u32)Thread::FileDescriptionBlocker::BlockFlags::Read)) {
if (!has_flag(unblocked_flags, BlockFlags::Read)) {
if (res.was_interrupted())
return EINTR;

2
Kernel/Net/LocalSocket.cpp
View file

@ -192,7 +192,7 @@ KResult LocalSocket::connect(FileDescription& description, Userspace<const socka
dbgln_if(LOCAL_SOCKET_DEBUG, "LocalSocket({}) connect({}) status is {}", this, safe_address, to_string(setup_state()));
if (!((u32)unblock_flags & (u32)Thread::FileDescriptionBlocker::BlockFlags::Connect)) {
if (!has_flag(unblock_flags, Thread::FileDescriptionBlocker::BlockFlags::Connect)) {
set_connect_side_role(Role::None);
return ECONNREFUSED;
}

10
Kernel/Syscalls/read.cpp
View file

@ -30,6 +30,8 @@
namespace Kernel {
using BlockFlags = Thread::FileBlocker::BlockFlags;
KResultOr<ssize_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
{
REQUIRE_PROMISE(stdio);
@ -65,10 +67,10 @@ KResultOr<ssize_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov
for (auto& vec : vecs) {
if (description->is_blocking()) {
if (!description->can_read()) {
auto unblock_flags = Thread::FileBlocker::BlockFlags::None;
auto unblock_flags = BlockFlags::None;
if (Thread::current()->block<Thread::ReadBlocker>({}, *description, unblock_flags).was_interrupted())
return EINTR;
if (!((u32)unblock_flags & (u32)Thread::FileBlocker::BlockFlags::Read))
if (!has_flag(unblock_flags, BlockFlags::Read))
return EAGAIN;
// TODO: handle exceptions in unblock_flags
}
@ -102,10 +104,10 @@ KResultOr<ssize_t> Process::sys$read(int fd, Userspace<u8*> buffer, ssize_t size
return EISDIR;
if (description->is_blocking()) {
if (!description->can_read()) {
auto unblock_flags = Thread::FileBlocker::BlockFlags::None;
auto unblock_flags = BlockFlags::None;
if (Thread::current()->block<Thread::ReadBlocker>({}, *description, unblock_flags).was_interrupted())
return EINTR;
if (!((u32)unblock_flags & (u32)Thread::FileBlocker::BlockFlags::Read))
if (!has_flag(unblock_flags, BlockFlags::Read))
return EAGAIN;
// TODO: handle exceptions in unblock_flags
}

48
Kernel/Syscalls/select.cpp
View file

@ -32,6 +32,8 @@
namespace Kernel {
using BlockFlags = Thread::FileBlocker::BlockFlags;
KResultOr<int> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params)
{
REQUIRE_PROMISE(stdio);
@ -76,14 +78,14 @@ KResultOr<int> Process::sys$select(Userspace<const Syscall::SC_select_params*> u
Thread::SelectBlocker::FDVector fds_info;
Vector<int, FD_SETSIZE> fds;
for (int fd = 0; fd < params.nfds; fd++) {
u32 block_flags = (u32)Thread::FileBlocker::BlockFlags::None;
auto block_flags = BlockFlags::None;
if (params.readfds && FD_ISSET(fd, &fds_read))
block_flags |= (u32)Thread::FileBlocker::BlockFlags::Read;
block_flags |= BlockFlags::Read;
if (params.writefds && FD_ISSET(fd, &fds_write))
block_flags |= (u32)Thread::FileBlocker::BlockFlags::Write;
block_flags |= BlockFlags::Write;
if (params.exceptfds && FD_ISSET(fd, &fds_except))
block_flags |= (u32)Thread::FileBlocker::BlockFlags::Exception;
if (block_flags == (u32)Thread::FileBlocker::BlockFlags::None)
block_flags |= BlockFlags::Exception;
if (block_flags == BlockFlags::None)
continue;
auto description = file_description(fd);
@ -91,7 +93,7 @@ KResultOr<int> Process::sys$select(Userspace<const Syscall::SC_select_params*> u
dbgln("sys$select: Bad fd number {}", fd);
return EBADF;
}
fds_info.append({ description.release_nonnull(), (Thread::FileBlocker::BlockFlags)block_flags });
fds_info.append({ description.release_nonnull(), block_flags });
fds.append(fd);
}
@ -113,17 +115,17 @@ KResultOr<int> Process::sys$select(Userspace<const Syscall::SC_select_params*> u
int marked_fd_count = 0;
for (size_t i = 0; i < fds_info.size(); i++) {
auto& fd_entry = fds_info[i];
if (fd_entry.unblocked_flags == Thread::FileBlocker::BlockFlags::None)
if (fd_entry.unblocked_flags == BlockFlags::None)
continue;
if (params.readfds && ((u32)fd_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Read)) {
if (params.readfds && has_flag(fd_entry.unblocked_flags, BlockFlags::Read)) {
FD_SET(fds[i], &fds_read);
marked_fd_count++;
}
if (params.writefds && ((u32)fd_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Write)) {
if (params.writefds && has_flag(fd_entry.unblocked_flags, BlockFlags::Write)) {
FD_SET(fds[i], &fds_write);
marked_fd_count++;
}
if (params.exceptfds && ((u32)fd_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Exception)) {
if (params.exceptfds && has_flag(fd_entry.unblocked_flags, BlockFlags::Exception)) {
FD_SET(fds[i], &fds_except);
marked_fd_count++;
}
@ -180,14 +182,14 @@ KResultOr<int> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_
dbgln("sys$poll: Bad fd number {}", pfd.fd);
return EBADF;
}
u32 block_flags = (u32)Thread::FileBlocker::BlockFlags::Exception; // always want POLLERR, POLLHUP, POLLNVAL
BlockFlags block_flags = BlockFlags::Exception; // always want POLLERR, POLLHUP, POLLNVAL
if (pfd.events & POLLIN)
block_flags |= (u32)Thread::FileBlocker::BlockFlags::Read;
block_flags |= BlockFlags::Read;
if (pfd.events & POLLOUT)
block_flags |= (u32)Thread::FileBlocker::BlockFlags::Write;
block_flags |= BlockFlags::Write;
if (pfd.events & POLLPRI)
block_flags |= (u32)Thread::FileBlocker::BlockFlags::ReadPriority;
fds_info.append({ description.release_nonnull(), (Thread::FileBlocker::BlockFlags)block_flags });
block_flags |= BlockFlags::ReadPriority;
fds_info.append({ description.release_nonnull(), block_flags });
}
auto current_thread = Thread::current();
@ -213,26 +215,26 @@ KResultOr<int> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_
auto& fds_entry = fds_info[i];
pfd.revents = 0;
if (fds_entry.unblocked_flags == Thread::FileBlocker::BlockFlags::None)
if (fds_entry.unblocked_flags == BlockFlags::None)
continue;
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Exception) {
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::ReadHangUp)
if (has_flag(fds_entry.unblocked_flags, BlockFlags::Exception)) {
if (has_flag(fds_entry.unblocked_flags, BlockFlags::ReadHangUp))
pfd.revents |= POLLRDHUP;
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::WriteError)
if (has_flag(fds_entry.unblocked_flags, BlockFlags::WriteError))
pfd.revents |= POLLERR;
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::WriteHangUp)
if (has_flag(fds_entry.unblocked_flags, BlockFlags::WriteHangUp))
pfd.revents |= POLLNVAL;
} else {
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Read) {
if (has_flag(fds_entry.unblocked_flags, BlockFlags::Read)) {
VERIFY(pfd.events & POLLIN);
pfd.revents |= POLLIN;
}
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::ReadPriority) {
if (has_flag(fds_entry.unblocked_flags, BlockFlags::ReadPriority)) {
VERIFY(pfd.events & POLLPRI);
pfd.revents |= POLLPRI;
}
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Write) {
if (has_flag(fds_entry.unblocked_flags, BlockFlags::Write)) {
VERIFY(pfd.events & POLLOUT);
pfd.revents |= POLLOUT;
}

3
Kernel/Thread.h
View file

@ -26,6 +26,7 @@
#pragma once
#include <AK/EnumBits.h>
#include <AK/Function.h>
#include <AK/HashMap.h>
#include <AK/IntrusiveList.h>
@ -1267,6 +1268,8 @@ private:
void drop_thread_count(bool);
};
AK_ENUM_BITWISE_OPERATORS(Thread::FileBlocker::BlockFlags);
template<typename Callback>
inline IterationDecision Thread::for_each(Callback callback)
{

8
Kernel/ThreadBlockers.cpp
View file

@ -265,17 +265,17 @@ const FileDescription& Thread::FileDescriptionBlocker::blocked_description() con
}
Thread::AcceptBlocker::AcceptBlocker(FileDescription& description, BlockFlags& unblocked_flags)
: FileDescriptionBlocker(description, (BlockFlags)((u32)BlockFlags::Accept | (u32)BlockFlags::Exception), unblocked_flags)
: FileDescriptionBlocker(description, BlockFlags::Accept | BlockFlags::Exception, unblocked_flags)
{
}
Thread::ConnectBlocker::ConnectBlocker(FileDescription& description, BlockFlags& unblocked_flags)
: FileDescriptionBlocker(description, (BlockFlags)((u32)BlockFlags::Connect | (u32)BlockFlags::Exception), unblocked_flags)
: FileDescriptionBlocker(description, BlockFlags::Connect | BlockFlags::Exception, unblocked_flags)
{
}
Thread::WriteBlocker::WriteBlocker(FileDescription& description, BlockFlags& unblocked_flags)
: FileDescriptionBlocker(description, (BlockFlags)((u32)BlockFlags::Write | (u32)BlockFlags::Exception), unblocked_flags)
: FileDescriptionBlocker(description, BlockFlags::Write | BlockFlags::Exception, unblocked_flags)
{
}
@ -295,7 +295,7 @@ auto Thread::WriteBlocker::override_timeout(const BlockTimeout& timeout) -> cons
}
Thread::ReadBlocker::ReadBlocker(FileDescription& description, BlockFlags& unblocked_flags)
: FileDescriptionBlocker(description, (BlockFlags)((u32)BlockFlags::Read | (u32)BlockFlags::Exception), unblocked_flags)
: FileDescriptionBlocker(description, BlockFlags::Read | BlockFlags::Exception, unblocked_flags)
{
}