RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-23 14:07:42 +00:00
Code Issues Activity Actions

Kernel: Port select to ThreadBlocker

Browse source
This commit is contained in:
Robin Burchell 2019-07-18 17:39:49 +02:00 • committed by Andreas Kling
parent 32fcfb79e9
commit 4f9ae9b970
4 changed files with 86 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

52
Kernel/Process.cpp
View file

@ -1792,13 +1792,17 @@ int Process::sys$select(const Syscall::SC_select_params* params)
if (params->nfds < 0)
return -EINVAL;
timeval timeout;
bool select_has_timeout = false;
if (params->timeout && (params->timeout->tv_sec || params->timeout->tv_usec)) {
timeval_add(kgettimeofday(), *params->timeout, current->m_select_timeout);
current->m_select_has_timeout = true;
} else {
current->m_select_has_timeout = false;
timeval_add(kgettimeofday(), *params->timeout, timeout);
select_has_timeout = true;
}
Vector<int> rfds;
Vector<int> wfds;
Vector<int> efds;
auto transfer_fds = [&](auto* fds, auto& vector) -> int {
vector.clear_with_capacity();
if (!fds)
@ -1812,19 +1816,19 @@ int Process::sys$select(const Syscall::SC_select_params* params)
}
return 0;
};
if (int error = transfer_fds(params->writefds, current->m_select_write_fds))
if (int error = transfer_fds(params->writefds, wfds))
return error;
if (int error = transfer_fds(params->readfds, current->m_select_read_fds))
if (int error = transfer_fds(params->readfds, rfds))
return error;
if (int error = transfer_fds(params->exceptfds, current->m_select_exceptional_fds))
if (int error = transfer_fds(params->exceptfds, efds))
return error;
#if defined(DEBUG_IO) || defined(DEBUG_POLL_SELECT)
dbgprintf("%s<%u> selecting on (read:%u, write:%u), timeout=%p\n", name().characters(), pid(), current->m_select_read_fds.size(), current->m_select_write_fds.size(), params->timeout);
dbgprintf("%s<%u> selecting on (read:%u, write:%u), timeout=%p\n", name().characters(), pid(), rfds.size(), wfds.size(), params->timeout);
#endif
if (!params->timeout || current->m_select_has_timeout)
current->block(Thread::State::BlockedSelect);
if (!params->timeout || select_has_timeout)
current->block(*new Thread::ThreadBlockerSelect(timeout, select_has_timeout, rfds, wfds, efds));
int marked_fd_count = 0;
auto mark_fds = [&](auto* fds, auto& vector, auto should_mark) {
@ -1838,8 +1842,8 @@ int Process::sys$select(const Syscall::SC_select_params* params)
}
}
};
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(); });
mark_fds(params->readfds, rfds, [](auto& description) { return description.can_read(); });
mark_fds(params->writefds, wfds, [](auto& description) { return description.can_write(); });
// FIXME: We should also mark params->exceptfds as appropriate.
return marked_fd_count;
}
@ -1849,15 +1853,18 @@ int Process::sys$poll(pollfd* fds, int nfds, int timeout)
if (!validate_read_typed(fds))
return -EFAULT;
current->m_select_write_fds.clear_with_capacity();
current->m_select_read_fds.clear_with_capacity();
Vector<int> rfds;
Vector<int> wfds;
for (int i = 0; i < nfds; ++i) {
if (fds[i].events & POLLIN)
current->m_select_read_fds.append(fds[i].fd);
rfds.append(fds[i].fd);
if (fds[i].events & POLLOUT)
current->m_select_write_fds.append(fds[i].fd);
wfds.append(fds[i].fd);
}
timeval actual_timeout;
bool has_timeout = false;
if (timeout >= 0) {
// poll is in ms, we want s/us.
struct timeval tvtimeout;
@ -1867,19 +1874,16 @@ int Process::sys$poll(pollfd* fds, int nfds, int timeout)
timeout -= 1000;
}
tvtimeout.tv_usec = timeout * 1000;
timeval_add(kgettimeofday(), tvtimeout, current->m_select_timeout);
current->m_select_has_timeout = true;
} else {
current->m_select_has_timeout = false;
timeval_add(kgettimeofday(), tvtimeout, actual_timeout);
has_timeout = true;
}
#if defined(DEBUG_IO) || defined(DEBUG_POLL_SELECT)
dbgprintf("%s<%u> polling on (read:%u, write:%u), timeout=%d\n", name().characters(), pid(), current->m_select_read_fds.size(), current->m_select_write_fds.size(), timeout);
dbgprintf("%s<%u> polling on (read:%u, write:%u), timeout=%d\n", name().characters(), pid(), rfds.size(), wfds.size(), timeout);
#endif
if (current->m_select_has_timeout || timeout < 0) {
current->block(Thread::State::BlockedSelect);
}
if (has_timeout|| timeout < 0)
current->block(*new Thread::ThreadBlockerSelect(actual_timeout, has_timeout, rfds, wfds, Vector<int>()));
int fds_with_revents = 0;

65
Kernel/Scheduler.cpp
View file

@ -65,7 +65,7 @@ Thread::ThreadBlockerAccept::ThreadBlockerAccept(const RefPtr<FileDescription>&
{
}
bool Thread::ThreadBlockerAccept::should_unblock(time_t, long)
bool Thread::ThreadBlockerAccept::should_unblock(Thread&, time_t, long)
{
auto& description = *blocked_description();
auto& socket = *description.socket();
@ -78,7 +78,7 @@ Thread::ThreadBlockerReceive::ThreadBlockerReceive(const RefPtr<FileDescription>
{
}
bool Thread::ThreadBlockerReceive::should_unblock(time_t now_sec, long now_usec)
bool Thread::ThreadBlockerReceive::should_unblock(Thread&, time_t now_sec, long now_usec)
{
auto& description = *blocked_description();
auto& socket = *description.socket();
@ -94,7 +94,7 @@ Thread::ThreadBlockerConnect::ThreadBlockerConnect(const RefPtr<FileDescription>
{
}
bool Thread::ThreadBlockerConnect::should_unblock(time_t, long)
bool Thread::ThreadBlockerConnect::should_unblock(Thread&, time_t, long)
{
auto& description = *blocked_description();
auto& socket = *description.socket();
@ -106,7 +106,7 @@ Thread::ThreadBlockerWrite::ThreadBlockerWrite(const RefPtr<FileDescription>& de
{
}
bool Thread::ThreadBlockerWrite::should_unblock(time_t, long)
bool Thread::ThreadBlockerWrite::should_unblock(Thread&, time_t, long)
{
return blocked_description()->can_write();
}
@ -116,7 +116,7 @@ Thread::ThreadBlockerRead::ThreadBlockerRead(const RefPtr<FileDescription>& desc
{
}
bool Thread::ThreadBlockerRead::should_unblock(time_t, long)
bool Thread::ThreadBlockerRead::should_unblock(Thread&, time_t, long)
{
// FIXME: Block until the amount of data wanted is available.
return blocked_description()->can_read();
@ -128,7 +128,7 @@ Thread::ThreadBlockerCondition::ThreadBlockerCondition(Function<bool()> &conditi
ASSERT(m_block_until_condition);
}
bool Thread::ThreadBlockerCondition::should_unblock(time_t, long)
bool Thread::ThreadBlockerCondition::should_unblock(Thread&, time_t, long)
{
return m_block_until_condition();
}
@ -138,11 +138,40 @@ Thread::ThreadBlockerSleep::ThreadBlockerSleep(u64 wakeup_time)
{
}
bool Thread::ThreadBlockerSleep::should_unblock(time_t, long)
bool Thread::ThreadBlockerSleep::should_unblock(Thread&, time_t, long)
{
return m_wakeup_time <= g_uptime;
}
Thread::ThreadBlockerSelect::ThreadBlockerSelect(const timeval& tv, bool select_has_timeout, const Vector<int>& read_fds, const Vector<int>& write_fds, const Vector<int>& except_fds)
: m_select_timeout(tv)
, m_select_has_timeout(select_has_timeout)
, m_select_read_fds(read_fds)
, m_select_write_fds(write_fds)
, m_select_exceptional_fds(except_fds)
{
}
bool Thread::ThreadBlockerSelect::should_unblock(Thread& thread, time_t now_sec, long now_usec)
{
if (m_select_has_timeout) {
if (now_sec > m_select_timeout.tv_sec || (now_sec == m_select_timeout.tv_sec && now_usec >= m_select_timeout.tv_usec))
return true;
}
auto& process = thread.process();
for (int fd : m_select_read_fds) {
if (process.m_fds[fd].description->can_read())
return true;
}
for (int fd : m_select_write_fds) {
if (process.m_fds[fd].description->can_write())
return true;
}
return false;
}
// Called by the scheduler on threads that are blocked for some reason.
// Make a decision as to whether to unblock them or not.
void Thread::consider_unblock(time_t now_sec, long now_usec)
@ -181,29 +210,9 @@ void Thread::consider_unblock(time_t now_sec, long now_usec)
return IterationDecision::Break;
});
return;
case Thread::BlockedSelect:
if (m_select_has_timeout) {
if (now_sec > m_select_timeout.tv_sec || (now_sec == m_select_timeout.tv_sec && now_usec >= m_select_timeout.tv_usec)) {
unblock();
return;
}
}
for (int fd : m_select_read_fds) {
if (process.m_fds[fd].description->can_read()) {
unblock();
return;
}
}
for (int fd : m_select_write_fds) {
if (process.m_fds[fd].description->can_write()) {
unblock();
return;
}
}
return;
case Thread::BlockedCondition:
ASSERT(m_blocker);
if (m_blocker->should_unblock(now_sec, now_usec)) {
if (m_blocker->should_unblock(*this, now_sec, now_usec)) {
unblock();
m_blocker = nullptr;
}

2
Kernel/Thread.cpp
View file

@ -166,8 +166,6 @@ const char* to_string(Thread::State state)
return "Wait";
case Thread::BlockedSignal:
return "Signal";
case Thread::BlockedSelect:
return "Select";
case Thread::BlockedLurking:
return "Lurking";
case Thread::BlockedCondition:

35
Kernel/Thread.h
View file

@ -67,7 +67,6 @@ public:
BlockedLurking,
BlockedWait,
BlockedSignal,
BlockedSelect,
BlockedCondition,
__End_Blocked_States__
};
@ -75,7 +74,7 @@ public:
class ThreadBlocker {
public:
virtual ~ThreadBlocker() {}
virtual bool should_unblock(time_t now_s, long us) = 0;
virtual bool should_unblock(Thread&, time_t now_s, long us) = 0;
};
class ThreadBlockerFileDescription : public ThreadBlocker {
@ -90,37 +89,37 @@ public:
class ThreadBlockerAccept : public ThreadBlockerFileDescription {
public:
ThreadBlockerAccept(const RefPtr<FileDescription>& description);
virtual bool should_unblock(time_t, long) override;
virtual bool should_unblock(Thread&, time_t, long) override;
};
class ThreadBlockerReceive : public ThreadBlockerFileDescription {
public:
ThreadBlockerReceive(const RefPtr<FileDescription>& description);
virtual bool should_unblock(time_t, long) override;
virtual bool should_unblock(Thread&, time_t, long) override;
};
class ThreadBlockerConnect : public ThreadBlockerFileDescription {
public:
ThreadBlockerConnect(const RefPtr<FileDescription>& description);
virtual bool should_unblock(time_t, long) override;
virtual bool should_unblock(Thread&, time_t, long) override;
};
class ThreadBlockerWrite : public ThreadBlockerFileDescription {
public:
ThreadBlockerWrite(const RefPtr<FileDescription>& description);
virtual bool should_unblock(time_t, long) override;
virtual bool should_unblock(Thread&, time_t, long) override;
};
class ThreadBlockerRead : public ThreadBlockerFileDescription {
public:
ThreadBlockerRead(const RefPtr<FileDescription>& description);
virtual bool should_unblock(time_t, long) override;
virtual bool should_unblock(Thread&, time_t, long) override;
};
class ThreadBlockerCondition : public ThreadBlocker {
public:
ThreadBlockerCondition(Function<bool()> &condition);
virtual bool should_unblock(time_t, long) override;
virtual bool should_unblock(Thread&, time_t, long) override;
private:
Function<bool()> m_block_until_condition;
@ -129,12 +128,25 @@ public:
class ThreadBlockerSleep : public ThreadBlocker {
public:
ThreadBlockerSleep(u64 wakeup_time);
virtual bool should_unblock(time_t, long) override;
virtual bool should_unblock(Thread&, time_t, long) override;
private:
u64 m_wakeup_time { 0 };
};
class ThreadBlockerSelect : public ThreadBlocker {
public:
ThreadBlockerSelect(const timeval& tv, bool select_has_timeout, const Vector<int>& read_fds, const Vector<int>& write_fds, const Vector<int>& except_fds);
virtual bool should_unblock(Thread&, time_t, long) override;
private:
timeval m_select_timeout;
bool m_select_has_timeout { false };
const Vector<int>& m_select_read_fds;
const Vector<int>& m_select_write_fds;
const Vector<int>& m_select_exceptional_fds;
};
void did_schedule() { ++m_times_scheduled; }
u32 times_scheduled() const { return m_times_scheduled; }
@ -240,17 +252,12 @@ private:
RefPtr<Region> m_kernel_stack_for_signal_handler_region;
pid_t m_waitee_pid { -1 };
int m_wait_options { 0 };
timeval m_select_timeout;
SignalActionData m_signal_action_data[32];
Region* m_signal_stack_user_region { nullptr };
OwnPtr<ThreadBlocker> m_blocker;
Vector<int> m_select_read_fds;
Vector<int> m_select_write_fds;
Vector<int> m_select_exceptional_fds;
FPUState* m_fpu_state { nullptr };
InlineLinkedList<Thread>* m_thread_list { nullptr };
State m_state { Invalid };
bool m_select_has_timeout { false };
bool m_has_used_fpu { false };
bool m_was_interrupted_while_blocked { false };
};