banan-os/kernel/kernel/Epoll.cpp

#include <kernel/Epoll.h>
#include <kernel/Lock/LockGuard.h>
#include <kernel/Timer/Timer.h>

namespace Kernel
{

	BAN::ErrorOr<BAN::RefPtr<Epoll>> Epoll::create()
	{
		auto* epoll_ptr = new Epoll();
		if (epoll_ptr == nullptr)
			return BAN::Error::from_errno(ENOMEM);
		return BAN::RefPtr<Epoll>::adopt(epoll_ptr);
	}

	Epoll::~Epoll()
	{
		for (auto [inode, _] : m_listening_events)
			inode->del_epoll(this);
	}

	BAN::ErrorOr<void> Epoll::ctl(int op, int fd, BAN::RefPtr<Inode> inode, epoll_event event)
	{
		LockGuard _(m_mutex);

		auto it = m_listening_events.find(inode);

		switch (op)
		{
			case EPOLL_CTL_ADD:
			{
				if (it == m_listening_events.end())
					it = TRY(m_listening_events.emplace(inode));
				if (it->value.has_fd(fd))
					return BAN::Error::from_errno(EEXIST);
				TRY(m_ready_events.reserve(m_listening_events.size()));
				TRY(inode->add_epoll(this));
				it->value.add_fd(fd, event);

				auto ready_it = m_ready_events.find(inode);
				if (ready_it == m_ready_events.end())
					ready_it = MUST(m_ready_events.insert(inode, 0));
				ready_it->value |= event.events;

				return {};
			}
			case EPOLL_CTL_MOD:
			{
				if (it == m_listening_events.end())
					return BAN::Error::from_errno(ENOENT);
				if (!it->value.has_fd(fd))
					return BAN::Error::from_errno(ENOENT);
				it->value.events[fd] = event;

				auto ready_it = m_ready_events.find(inode);
				if (ready_it == m_ready_events.end())
					ready_it = MUST(m_ready_events.insert(inode, 0));
				ready_it->value |= event.events;

				return {};
			}
			case EPOLL_CTL_DEL:
			{
				if (it == m_listening_events.end())
					return BAN::Error::from_errno(ENOENT);
				if (!it->value.has_fd(fd))
					return BAN::Error::from_errno(ENOENT);
				it->value.remove_fd(fd);
				if (it->value.empty())
				{
					m_listening_events.remove(it);
					m_ready_events.remove(inode);
				}
				return {};
			}
		}

		return BAN::Error::from_errno(EINVAL);
	}

	BAN::ErrorOr<size_t> Epoll::wait(BAN::Span<epoll_event> event_span, uint64_t waketime_ns)
	{
		if (event_span.empty())
			return BAN::Error::from_errno(EINVAL);

		size_t count = 0;

		for (;;)
		{
			bool failed_lock = false;

			{
				LockGuard _(m_mutex);

				for (auto it = m_ready_events.begin(); it != m_ready_events.end() && count < event_span.size();)
				{
					auto& [inode, events] = *it;

					auto& listen = m_listening_events[inode];

					uint32_t listen_mask = EPOLLERR | EPOLLHUP;
					for (int fd = 0; fd < OPEN_MAX; fd++)
						if (listen.has_fd(fd))
							listen_mask |= listen.events[fd].events;
					events &= listen_mask;

					// This prevents a possible deadlock
					if (!inode->m_mutex.try_lock())
					{
						failed_lock = true;
						continue;
					}

#define CHECK_EVENT_BIT(mask, func) \
					if ((events & mask) && !inode->func()) \
						events &= ~mask;
					CHECK_EVENT_BIT(EPOLLIN, can_read);
					CHECK_EVENT_BIT(EPOLLOUT, can_write);
					CHECK_EVENT_BIT(EPOLLERR, has_error);
					CHECK_EVENT_BIT(EPOLLHUP, has_hungup);
#undef CHECK_EVENT_BIT

					inode->m_mutex.unlock();

					if (events == 0)
					{
						m_ready_events.remove(it);
						it = m_ready_events.begin();
						continue;
					}

					for (int fd = 0; fd < OPEN_MAX && count < event_span.size(); fd++)
					{
						if (!listen.has_fd(fd))
							continue;
						auto& listen_event = listen.events[fd];

						const auto new_events = listen_event.events & events;
						if (new_events == 0)
							continue;

						event_span[count++] = {
							.events = new_events,
							.data = listen_event.data,
						};

						if (listen_event.events & EPOLLONESHOT)
							listen_event.events = 0;
						// this doesn't work with multiple of the same inode
						if (listen_event.events & EPOLLET)
							events &= ~new_events;
					}

					it++;
				}
			}

			if (count)
				break;

			const uint64_t current_ns = SystemTimer::get().ns_since_boot();
			if (current_ns >= waketime_ns)
				break;
			if (failed_lock)
				continue;
			const uint64_t timeout_ns = BAN::Math::min<uint64_t>(100'000'000, waketime_ns - current_ns);
			TRY(Thread::current().block_or_eintr_or_timeout_ns(m_thread_blocker, timeout_ns, false));
		}

		return count;
	}

	void Epoll::notify(BAN::RefPtr<Inode> inode, uint32_t event)
	{
		LockGuard _(m_mutex);

		if (!m_listening_events.contains(inode))
			return;

		auto ready_it = m_ready_events.find(inode);
		if (ready_it == m_ready_events.end())
			ready_it = MUST(m_ready_events.insert(inode, 0));
		ready_it->value |= event;

		m_thread_blocker.unblock();
	}

}