mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 11:28:12 +00:00
79fa9765ca
We now use AK::Error and AK::ErrorOr<T> in both kernel and userspace! This was a slightly tedious refactoring that took a long time, so it's not unlikely that some bugs crept in. Nevertheless, it does pass basic functionality testing, and it's just real nice to finally see the same pattern in all contexts. :^)
226 lines
7.5 KiB
C++
226 lines
7.5 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/ScopeGuard.h>
|
|
#include <AK/Time.h>
|
|
#include <Kernel/Debug.h>
|
|
#include <Kernel/FileSystem/OpenFileDescription.h>
|
|
#include <Kernel/Process.h>
|
|
|
|
namespace Kernel {
|
|
|
|
using BlockFlags = Thread::FileBlocker::BlockFlags;
|
|
|
|
ErrorOr<FlatPtr> Process::sys$select(Userspace<const Syscall::SC_select_params*> user_params)
|
|
{
|
|
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
|
|
REQUIRE_PROMISE(stdio);
|
|
|
|
auto params = TRY(copy_typed_from_user(user_params));
|
|
|
|
if (params.nfds < 0)
|
|
return EINVAL;
|
|
|
|
Thread::BlockTimeout timeout;
|
|
if (params.timeout) {
|
|
auto timeout_time = TRY(copy_time_from_user(params.timeout));
|
|
timeout = Thread::BlockTimeout(false, &timeout_time);
|
|
}
|
|
|
|
auto current_thread = Thread::current();
|
|
|
|
u32 previous_signal_mask = 0;
|
|
if (params.sigmask) {
|
|
sigset_t sigmask_copy;
|
|
TRY(copy_from_user(&sigmask_copy, params.sigmask));
|
|
previous_signal_mask = current_thread->update_signal_mask(sigmask_copy);
|
|
}
|
|
ScopeGuard rollback_signal_mask([&]() {
|
|
if (params.sigmask)
|
|
current_thread->update_signal_mask(previous_signal_mask);
|
|
});
|
|
|
|
fd_set fds_read, fds_write, fds_except;
|
|
|
|
size_t bytes_used = ceil_div(params.nfds, 8);
|
|
if (bytes_used > sizeof(fds_read))
|
|
return EINVAL;
|
|
|
|
if (params.readfds)
|
|
TRY(copy_from_user(&fds_read, params.readfds, bytes_used));
|
|
|
|
if (params.writefds)
|
|
TRY(copy_from_user(&fds_write, params.writefds, bytes_used));
|
|
|
|
if (params.exceptfds)
|
|
TRY(copy_from_user(&fds_except, params.exceptfds, bytes_used));
|
|
|
|
Thread::SelectBlocker::FDVector fds_info;
|
|
Vector<int, FD_SETSIZE> selected_fds;
|
|
for (int fd = 0; fd < params.nfds; fd++) {
|
|
auto block_flags = BlockFlags::None;
|
|
if (params.readfds && FD_ISSET(fd, &fds_read))
|
|
block_flags |= BlockFlags::Read;
|
|
if (params.writefds && FD_ISSET(fd, &fds_write))
|
|
block_flags |= BlockFlags::Write;
|
|
if (params.exceptfds && FD_ISSET(fd, &fds_except))
|
|
block_flags |= BlockFlags::Exception;
|
|
if (block_flags == BlockFlags::None)
|
|
continue;
|
|
|
|
auto description = TRY(fds().open_file_description(fd));
|
|
if (!fds_info.try_append({ move(description), block_flags }))
|
|
return ENOMEM;
|
|
if (!selected_fds.try_append(fd))
|
|
return ENOMEM;
|
|
}
|
|
|
|
if constexpr (IO_DEBUG || POLL_SELECT_DEBUG)
|
|
dbgln("selecting on {} fds, timeout={}", fds_info.size(), params.timeout);
|
|
|
|
if (current_thread->block<Thread::SelectBlocker>(timeout, fds_info).was_interrupted()) {
|
|
dbgln_if(POLL_SELECT_DEBUG, "select was interrupted");
|
|
return EINTR;
|
|
}
|
|
|
|
if (params.readfds)
|
|
FD_ZERO(&fds_read);
|
|
if (params.writefds)
|
|
FD_ZERO(&fds_write);
|
|
if (params.exceptfds)
|
|
FD_ZERO(&fds_except);
|
|
|
|
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 == BlockFlags::None)
|
|
continue;
|
|
if (params.readfds && has_flag(fd_entry.unblocked_flags, BlockFlags::Read)) {
|
|
FD_SET(selected_fds[i], &fds_read);
|
|
marked_fd_count++;
|
|
}
|
|
if (params.writefds && has_flag(fd_entry.unblocked_flags, BlockFlags::Write)) {
|
|
FD_SET(selected_fds[i], &fds_write);
|
|
marked_fd_count++;
|
|
}
|
|
if (params.exceptfds && has_any_flag(fd_entry.unblocked_flags, BlockFlags::Exception)) {
|
|
FD_SET(selected_fds[i], &fds_except);
|
|
marked_fd_count++;
|
|
}
|
|
}
|
|
|
|
if (params.readfds)
|
|
TRY(copy_to_user(params.readfds, &fds_read, bytes_used));
|
|
if (params.writefds)
|
|
TRY(copy_to_user(params.writefds, &fds_write, bytes_used));
|
|
if (params.exceptfds)
|
|
TRY(copy_to_user(params.exceptfds, &fds_except, bytes_used));
|
|
return marked_fd_count;
|
|
}
|
|
|
|
ErrorOr<FlatPtr> Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
|
|
{
|
|
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
|
|
REQUIRE_PROMISE(stdio);
|
|
auto params = TRY(copy_typed_from_user(user_params));
|
|
|
|
if (params.nfds >= fds().max_open())
|
|
return ENOBUFS;
|
|
|
|
Thread::BlockTimeout timeout;
|
|
if (params.timeout) {
|
|
auto timeout_time = TRY(copy_time_from_user(params.timeout));
|
|
timeout = Thread::BlockTimeout(false, &timeout_time);
|
|
}
|
|
|
|
sigset_t sigmask = {};
|
|
if (params.sigmask)
|
|
TRY(copy_from_user(&sigmask, params.sigmask));
|
|
|
|
Vector<pollfd, FD_SETSIZE> fds_copy;
|
|
if (params.nfds > 0) {
|
|
Checked<size_t> nfds_checked = sizeof(pollfd);
|
|
nfds_checked *= params.nfds;
|
|
if (nfds_checked.has_overflow())
|
|
return EFAULT;
|
|
if (!fds_copy.try_resize(params.nfds))
|
|
return ENOMEM;
|
|
TRY(copy_from_user(fds_copy.data(), ¶ms.fds[0], nfds_checked.value()));
|
|
}
|
|
|
|
Thread::SelectBlocker::FDVector fds_info;
|
|
for (size_t i = 0; i < params.nfds; i++) {
|
|
auto& pfd = fds_copy[i];
|
|
auto description = TRY(fds().open_file_description(pfd.fd));
|
|
BlockFlags block_flags = BlockFlags::Exception; // always want POLLERR, POLLHUP, POLLNVAL
|
|
if (pfd.events & POLLIN)
|
|
block_flags |= BlockFlags::Read;
|
|
if (pfd.events & POLLOUT)
|
|
block_flags |= BlockFlags::Write;
|
|
if (pfd.events & POLLPRI)
|
|
block_flags |= BlockFlags::ReadPriority;
|
|
if (!fds_info.try_append({ move(description), block_flags }))
|
|
return ENOMEM;
|
|
}
|
|
|
|
auto current_thread = Thread::current();
|
|
|
|
u32 previous_signal_mask = 0;
|
|
if (params.sigmask)
|
|
previous_signal_mask = current_thread->update_signal_mask(sigmask);
|
|
ScopeGuard rollback_signal_mask([&]() {
|
|
if (params.sigmask)
|
|
current_thread->update_signal_mask(previous_signal_mask);
|
|
});
|
|
|
|
if constexpr (IO_DEBUG || POLL_SELECT_DEBUG)
|
|
dbgln("polling on {} fds, timeout={}", fds_info.size(), params.timeout);
|
|
|
|
if (current_thread->block<Thread::SelectBlocker>(timeout, fds_info).was_interrupted())
|
|
return EINTR;
|
|
|
|
int fds_with_revents = 0;
|
|
|
|
for (unsigned i = 0; i < params.nfds; ++i) {
|
|
auto& pfd = fds_copy[i];
|
|
auto& fds_entry = fds_info[i];
|
|
|
|
pfd.revents = 0;
|
|
if (fds_entry.unblocked_flags == BlockFlags::None)
|
|
continue;
|
|
|
|
if (has_any_flag(fds_entry.unblocked_flags, BlockFlags::Exception)) {
|
|
if (has_flag(fds_entry.unblocked_flags, BlockFlags::ReadHangUp))
|
|
pfd.revents |= POLLRDHUP;
|
|
if (has_flag(fds_entry.unblocked_flags, BlockFlags::WriteError))
|
|
pfd.revents |= POLLERR;
|
|
if (has_flag(fds_entry.unblocked_flags, BlockFlags::WriteHangUp))
|
|
pfd.revents |= POLLNVAL;
|
|
} else {
|
|
if (has_flag(fds_entry.unblocked_flags, BlockFlags::Read)) {
|
|
VERIFY(pfd.events & POLLIN);
|
|
pfd.revents |= POLLIN;
|
|
}
|
|
if (has_flag(fds_entry.unblocked_flags, BlockFlags::ReadPriority)) {
|
|
VERIFY(pfd.events & POLLPRI);
|
|
pfd.revents |= POLLPRI;
|
|
}
|
|
if (has_flag(fds_entry.unblocked_flags, BlockFlags::Write)) {
|
|
VERIFY(pfd.events & POLLOUT);
|
|
pfd.revents |= POLLOUT;
|
|
}
|
|
}
|
|
if (pfd.revents)
|
|
fds_with_revents++;
|
|
}
|
|
|
|
if (params.nfds > 0)
|
|
TRY(copy_to_user(¶ms.fds[0], fds_copy.data(), params.nfds * sizeof(pollfd)));
|
|
|
|
return fds_with_revents;
|
|
}
|
|
|
|
}
|