aboutsummaryrefslogtreecommitdiffstats
path: root/lib/asio/detail/impl/epoll_reactor.ipp
diff options
context:
space:
mode:
authorMatthias P. Braendli <matthias.braendli@mpb.li>2019-10-07 04:52:50 +0200
committerMatthias P. Braendli <matthias.braendli@mpb.li>2019-10-07 04:52:50 +0200
commit0aa6201a490bfabc0ae021ceb9f1fb0f46727c5d (patch)
treea71d934d8151dd43e7c16555fef17fd749c5da70 /lib/asio/detail/impl/epoll_reactor.ipp
parent558d74bffd9f069955af52c0b308a1d6169bcff0 (diff)
parent0330221d51421caa110b8c5dcb567cc3d0620eb9 (diff)
downloaddabmod-0aa6201a490bfabc0ae021ceb9f1fb0f46727c5d.tar.gz
dabmod-0aa6201a490bfabc0ae021ceb9f1fb0f46727c5d.tar.bz2
dabmod-0aa6201a490bfabc0ae021ceb9f1fb0f46727c5d.zip
Merge lime output into next branch
Diffstat (limited to 'lib/asio/detail/impl/epoll_reactor.ipp')
-rw-r--r--lib/asio/detail/impl/epoll_reactor.ipp787
1 files changed, 0 insertions, 787 deletions
diff --git a/lib/asio/detail/impl/epoll_reactor.ipp b/lib/asio/detail/impl/epoll_reactor.ipp
deleted file mode 100644
index 65584a4..0000000
--- a/lib/asio/detail/impl/epoll_reactor.ipp
+++ /dev/null
@@ -1,787 +0,0 @@
-//
-// detail/impl/epoll_reactor.ipp
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
-#define ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-
-#include "asio/detail/config.hpp"
-
-#if defined(ASIO_HAS_EPOLL)
-
-#include <cstddef>
-#include <sys/epoll.h>
-#include "asio/detail/epoll_reactor.hpp"
-#include "asio/detail/throw_error.hpp"
-#include "asio/error.hpp"
-
-#if defined(ASIO_HAS_TIMERFD)
-# include <sys/timerfd.h>
-#endif // defined(ASIO_HAS_TIMERFD)
-
-#include "asio/detail/push_options.hpp"
-
-namespace asio {
-namespace detail {
-
-epoll_reactor::epoll_reactor(asio::execution_context& ctx)
- : execution_context_service_base<epoll_reactor>(ctx),
- scheduler_(use_service<scheduler>(ctx)),
- mutex_(ASIO_CONCURRENCY_HINT_IS_LOCKING(
- REACTOR_REGISTRATION, scheduler_.concurrency_hint())),
- interrupter_(),
- epoll_fd_(do_epoll_create()),
- timer_fd_(do_timerfd_create()),
- shutdown_(false),
- registered_descriptors_mutex_(mutex_.enabled())
-{
- // Add the interrupter's descriptor to epoll.
- epoll_event ev = { 0, { 0 } };
- ev.events = EPOLLIN | EPOLLERR | EPOLLET;
- ev.data.ptr = &interrupter_;
- epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
- interrupter_.interrupt();
-
- // Add the timer descriptor to epoll.
- if (timer_fd_ != -1)
- {
- ev.events = EPOLLIN | EPOLLERR;
- ev.data.ptr = &timer_fd_;
- epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
- }
-}
-
-epoll_reactor::~epoll_reactor()
-{
- if (epoll_fd_ != -1)
- close(epoll_fd_);
- if (timer_fd_ != -1)
- close(timer_fd_);
-}
-
-void epoll_reactor::shutdown()
-{
- mutex::scoped_lock lock(mutex_);
- shutdown_ = true;
- lock.unlock();
-
- op_queue<operation> ops;
-
- while (descriptor_state* state = registered_descriptors_.first())
- {
- for (int i = 0; i < max_ops; ++i)
- ops.push(state->op_queue_[i]);
- state->shutdown_ = true;
- registered_descriptors_.free(state);
- }
-
- timer_queues_.get_all_timers(ops);
-
- scheduler_.abandon_operations(ops);
-}
-
-void epoll_reactor::notify_fork(
- asio::execution_context::fork_event fork_ev)
-{
- if (fork_ev == asio::execution_context::fork_child)
- {
- if (epoll_fd_ != -1)
- ::close(epoll_fd_);
- epoll_fd_ = -1;
- epoll_fd_ = do_epoll_create();
-
- if (timer_fd_ != -1)
- ::close(timer_fd_);
- timer_fd_ = -1;
- timer_fd_ = do_timerfd_create();
-
- interrupter_.recreate();
-
- // Add the interrupter's descriptor to epoll.
- epoll_event ev = { 0, { 0 } };
- ev.events = EPOLLIN | EPOLLERR | EPOLLET;
- ev.data.ptr = &interrupter_;
- epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev);
- interrupter_.interrupt();
-
- // Add the timer descriptor to epoll.
- if (timer_fd_ != -1)
- {
- ev.events = EPOLLIN | EPOLLERR;
- ev.data.ptr = &timer_fd_;
- epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev);
- }
-
- update_timeout();
-
- // Re-register all descriptors with epoll.
- mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
- for (descriptor_state* state = registered_descriptors_.first();
- state != 0; state = state->next_)
- {
- ev.events = state->registered_events_;
- ev.data.ptr = state;
- int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, state->descriptor_, &ev);
- if (result != 0)
- {
- asio::error_code ec(errno,
- asio::error::get_system_category());
- asio::detail::throw_error(ec, "epoll re-registration");
- }
- }
- }
-}
-
-void epoll_reactor::init_task()
-{
- scheduler_.init_task();
-}
-
-int epoll_reactor::register_descriptor(socket_type descriptor,
- epoll_reactor::per_descriptor_data& descriptor_data)
-{
- descriptor_data = allocate_descriptor_state();
-
- ASIO_HANDLER_REACTOR_REGISTRATION((
- context(), static_cast<uintmax_t>(descriptor),
- reinterpret_cast<uintmax_t>(descriptor_data)));
-
- {
- mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
- descriptor_data->reactor_ = this;
- descriptor_data->descriptor_ = descriptor;
- descriptor_data->shutdown_ = false;
- for (int i = 0; i < max_ops; ++i)
- descriptor_data->try_speculative_[i] = true;
- }
-
- epoll_event ev = { 0, { 0 } };
- ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
- descriptor_data->registered_events_ = ev.events;
- ev.data.ptr = descriptor_data;
- int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
- if (result != 0)
- {
- if (errno == EPERM)
- {
- // This file descriptor type is not supported by epoll. However, if it is
- // a regular file then operations on it will not block. We will allow
- // this descriptor to be used and fail later if an operation on it would
- // otherwise require a trip through the reactor.
- descriptor_data->registered_events_ = 0;
- return 0;
- }
- return errno;
- }
-
- return 0;
-}
-
-int epoll_reactor::register_internal_descriptor(
- int op_type, socket_type descriptor,
- epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
-{
- descriptor_data = allocate_descriptor_state();
-
- ASIO_HANDLER_REACTOR_REGISTRATION((
- context(), static_cast<uintmax_t>(descriptor),
- reinterpret_cast<uintmax_t>(descriptor_data)));
-
- {
- mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
- descriptor_data->reactor_ = this;
- descriptor_data->descriptor_ = descriptor;
- descriptor_data->shutdown_ = false;
- descriptor_data->op_queue_[op_type].push(op);
- for (int i = 0; i < max_ops; ++i)
- descriptor_data->try_speculative_[i] = true;
- }
-
- epoll_event ev = { 0, { 0 } };
- ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLPRI | EPOLLET;
- descriptor_data->registered_events_ = ev.events;
- ev.data.ptr = descriptor_data;
- int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev);
- if (result != 0)
- return errno;
-
- return 0;
-}
-
-void epoll_reactor::move_descriptor(socket_type,
- epoll_reactor::per_descriptor_data& target_descriptor_data,
- epoll_reactor::per_descriptor_data& source_descriptor_data)
-{
- target_descriptor_data = source_descriptor_data;
- source_descriptor_data = 0;
-}
-
-void epoll_reactor::start_op(int op_type, socket_type descriptor,
- epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
- bool is_continuation, bool allow_speculative)
-{
- if (!descriptor_data)
- {
- op->ec_ = asio::error::bad_descriptor;
- post_immediate_completion(op, is_continuation);
- return;
- }
-
- mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
- if (descriptor_data->shutdown_)
- {
- post_immediate_completion(op, is_continuation);
- return;
- }
-
- if (descriptor_data->op_queue_[op_type].empty())
- {
- if (allow_speculative
- && (op_type != read_op
- || descriptor_data->op_queue_[except_op].empty()))
- {
- if (descriptor_data->try_speculative_[op_type])
- {
- if (reactor_op::status status = op->perform())
- {
- if (status == reactor_op::done_and_exhausted)
- if (descriptor_data->registered_events_ != 0)
- descriptor_data->try_speculative_[op_type] = false;
- descriptor_lock.unlock();
- scheduler_.post_immediate_completion(op, is_continuation);
- return;
- }
- }
-
- if (descriptor_data->registered_events_ == 0)
- {
- op->ec_ = asio::error::operation_not_supported;
- scheduler_.post_immediate_completion(op, is_continuation);
- return;
- }
-
- if (op_type == write_op)
- {
- if ((descriptor_data->registered_events_ & EPOLLOUT) == 0)
- {
- epoll_event ev = { 0, { 0 } };
- ev.events = descriptor_data->registered_events_ | EPOLLOUT;
- ev.data.ptr = descriptor_data;
- if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev) == 0)
- {
- descriptor_data->registered_events_ |= ev.events;
- }
- else
- {
- op->ec_ = asio::error_code(errno,
- asio::error::get_system_category());
- scheduler_.post_immediate_completion(op, is_continuation);
- return;
- }
- }
- }
- }
- else if (descriptor_data->registered_events_ == 0)
- {
- op->ec_ = asio::error::operation_not_supported;
- scheduler_.post_immediate_completion(op, is_continuation);
- return;
- }
- else
- {
- if (op_type == write_op)
- {
- descriptor_data->registered_events_ |= EPOLLOUT;
- }
-
- epoll_event ev = { 0, { 0 } };
- ev.events = descriptor_data->registered_events_;
- ev.data.ptr = descriptor_data;
- epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev);
- }
- }
-
- descriptor_data->op_queue_[op_type].push(op);
- scheduler_.work_started();
-}
-
-void epoll_reactor::cancel_ops(socket_type,
- epoll_reactor::per_descriptor_data& descriptor_data)
-{
- if (!descriptor_data)
- return;
-
- mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
- op_queue<operation> ops;
- for (int i = 0; i < max_ops; ++i)
- {
- while (reactor_op* op = descriptor_data->op_queue_[i].front())
- {
- op->ec_ = asio::error::operation_aborted;
- descriptor_data->op_queue_[i].pop();
- ops.push(op);
- }
- }
-
- descriptor_lock.unlock();
-
- scheduler_.post_deferred_completions(ops);
-}
-
-void epoll_reactor::deregister_descriptor(socket_type descriptor,
- epoll_reactor::per_descriptor_data& descriptor_data, bool closing)
-{
- if (!descriptor_data)
- return;
-
- mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
- if (!descriptor_data->shutdown_)
- {
- if (closing)
- {
- // The descriptor will be automatically removed from the epoll set when
- // it is closed.
- }
- else if (descriptor_data->registered_events_ != 0)
- {
- epoll_event ev = { 0, { 0 } };
- epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
- }
-
- op_queue<operation> ops;
- for (int i = 0; i < max_ops; ++i)
- {
- while (reactor_op* op = descriptor_data->op_queue_[i].front())
- {
- op->ec_ = asio::error::operation_aborted;
- descriptor_data->op_queue_[i].pop();
- ops.push(op);
- }
- }
-
- descriptor_data->descriptor_ = -1;
- descriptor_data->shutdown_ = true;
-
- descriptor_lock.unlock();
-
- ASIO_HANDLER_REACTOR_DEREGISTRATION((
- context(), static_cast<uintmax_t>(descriptor),
- reinterpret_cast<uintmax_t>(descriptor_data)));
-
- scheduler_.post_deferred_completions(ops);
-
- // Leave descriptor_data set so that it will be freed by the subsequent
- // call to cleanup_descriptor_data.
- }
- else
- {
- // We are shutting down, so prevent cleanup_descriptor_data from freeing
- // the descriptor_data object and let the destructor free it instead.
- descriptor_data = 0;
- }
-}
-
-void epoll_reactor::deregister_internal_descriptor(socket_type descriptor,
- epoll_reactor::per_descriptor_data& descriptor_data)
-{
- if (!descriptor_data)
- return;
-
- mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
-
- if (!descriptor_data->shutdown_)
- {
- epoll_event ev = { 0, { 0 } };
- epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev);
-
- op_queue<operation> ops;
- for (int i = 0; i < max_ops; ++i)
- ops.push(descriptor_data->op_queue_[i]);
-
- descriptor_data->descriptor_ = -1;
- descriptor_data->shutdown_ = true;
-
- descriptor_lock.unlock();
-
- ASIO_HANDLER_REACTOR_DEREGISTRATION((
- context(), static_cast<uintmax_t>(descriptor),
- reinterpret_cast<uintmax_t>(descriptor_data)));
-
- // Leave descriptor_data set so that it will be freed by the subsequent
- // call to cleanup_descriptor_data.
- }
- else
- {
- // We are shutting down, so prevent cleanup_descriptor_data from freeing
- // the descriptor_data object and let the destructor free it instead.
- descriptor_data = 0;
- }
-}
-
-void epoll_reactor::cleanup_descriptor_data(
- per_descriptor_data& descriptor_data)
-{
- if (descriptor_data)
- {
- free_descriptor_state(descriptor_data);
- descriptor_data = 0;
- }
-}
-
-void epoll_reactor::run(long usec, op_queue<operation>& ops)
-{
- // This code relies on the fact that the scheduler queues the reactor task
- // behind all descriptor operations generated by this function. This means,
- // that by the time we reach this point, any previously returned descriptor
- // operations have already been dequeued. Therefore it is now safe for us to
- // reuse and return them for the scheduler to queue again.
-
- // Calculate timeout. Check the timer queues only if timerfd is not in use.
- int timeout;
- if (usec == 0)
- timeout = 0;
- else
- {
- timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1);
- if (timer_fd_ == -1)
- {
- mutex::scoped_lock lock(mutex_);
- timeout = get_timeout(timeout);
- }
- }
-
- // Block on the epoll descriptor.
- epoll_event events[128];
- int num_events = epoll_wait(epoll_fd_, events, 128, timeout);
-
-#if defined(ASIO_ENABLE_HANDLER_TRACKING)
- // Trace the waiting events.
- for (int i = 0; i < num_events; ++i)
- {
- void* ptr = events[i].data.ptr;
- if (ptr == &interrupter_)
- {
- // Ignore.
- }
-# if defined(ASIO_HAS_TIMERFD)
- else if (ptr == &timer_fd_)
- {
- // Ignore.
- }
-# endif // defined(ASIO_HAS_TIMERFD)
- else
- {
- unsigned event_mask = 0;
- if ((events[i].events & EPOLLIN) != 0)
- event_mask |= ASIO_HANDLER_REACTOR_READ_EVENT;
- if ((events[i].events & EPOLLOUT))
- event_mask |= ASIO_HANDLER_REACTOR_WRITE_EVENT;
- if ((events[i].events & (EPOLLERR | EPOLLHUP)) != 0)
- event_mask |= ASIO_HANDLER_REACTOR_ERROR_EVENT;
- ASIO_HANDLER_REACTOR_EVENTS((context(),
- reinterpret_cast<uintmax_t>(ptr), event_mask));
- }
- }
-#endif // defined(ASIO_ENABLE_HANDLER_TRACKING)
-
-#if defined(ASIO_HAS_TIMERFD)
- bool check_timers = (timer_fd_ == -1);
-#else // defined(ASIO_HAS_TIMERFD)
- bool check_timers = true;
-#endif // defined(ASIO_HAS_TIMERFD)
-
- // Dispatch the waiting events.
- for (int i = 0; i < num_events; ++i)
- {
- void* ptr = events[i].data.ptr;
- if (ptr == &interrupter_)
- {
- // No need to reset the interrupter since we're leaving the descriptor
- // in a ready-to-read state and relying on edge-triggered notifications
- // to make it so that we only get woken up when the descriptor's epoll
- // registration is updated.
-
-#if defined(ASIO_HAS_TIMERFD)
- if (timer_fd_ == -1)
- check_timers = true;
-#else // defined(ASIO_HAS_TIMERFD)
- check_timers = true;
-#endif // defined(ASIO_HAS_TIMERFD)
- }
-#if defined(ASIO_HAS_TIMERFD)
- else if (ptr == &timer_fd_)
- {
- check_timers = true;
- }
-#endif // defined(ASIO_HAS_TIMERFD)
- else
- {
- // The descriptor operation doesn't count as work in and of itself, so we
- // don't call work_started() here. This still allows the scheduler to
- // stop if the only remaining operations are descriptor operations.
- descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
- if (!ops.is_enqueued(descriptor_data))
- {
- descriptor_data->set_ready_events(events[i].events);
- ops.push(descriptor_data);
- }
- else
- {
- descriptor_data->add_ready_events(events[i].events);
- }
- }
- }
-
- if (check_timers)
- {
- mutex::scoped_lock common_lock(mutex_);
- timer_queues_.get_ready_timers(ops);
-
-#if defined(ASIO_HAS_TIMERFD)
- if (timer_fd_ != -1)
- {
- itimerspec new_timeout;
- itimerspec old_timeout;
- int flags = get_timeout(new_timeout);
- timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
- }
-#endif // defined(ASIO_HAS_TIMERFD)
- }
-}
-
-void epoll_reactor::interrupt()
-{
- epoll_event ev = { 0, { 0 } };
- ev.events = EPOLLIN | EPOLLERR | EPOLLET;
- ev.data.ptr = &interrupter_;
- epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, interrupter_.read_descriptor(), &ev);
-}
-
-int epoll_reactor::do_epoll_create()
-{
-#if defined(EPOLL_CLOEXEC)
- int fd = epoll_create1(EPOLL_CLOEXEC);
-#else // defined(EPOLL_CLOEXEC)
- int fd = -1;
- errno = EINVAL;
-#endif // defined(EPOLL_CLOEXEC)
-
- if (fd == -1 && (errno == EINVAL || errno == ENOSYS))
- {
- fd = epoll_create(epoll_size);
- if (fd != -1)
- ::fcntl(fd, F_SETFD, FD_CLOEXEC);
- }
-
- if (fd == -1)
- {
- asio::error_code ec(errno,
- asio::error::get_system_category());
- asio::detail::throw_error(ec, "epoll");
- }
-
- return fd;
-}
-
-int epoll_reactor::do_timerfd_create()
-{
-#if defined(ASIO_HAS_TIMERFD)
-# if defined(TFD_CLOEXEC)
- int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
-# else // defined(TFD_CLOEXEC)
- int fd = -1;
- errno = EINVAL;
-# endif // defined(TFD_CLOEXEC)
-
- if (fd == -1 && errno == EINVAL)
- {
- fd = timerfd_create(CLOCK_MONOTONIC, 0);
- if (fd != -1)
- ::fcntl(fd, F_SETFD, FD_CLOEXEC);
- }
-
- return fd;
-#else // defined(ASIO_HAS_TIMERFD)
- return -1;
-#endif // defined(ASIO_HAS_TIMERFD)
-}
-
-epoll_reactor::descriptor_state* epoll_reactor::allocate_descriptor_state()
-{
- mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
- return registered_descriptors_.alloc(ASIO_CONCURRENCY_HINT_IS_LOCKING(
- REACTOR_IO, scheduler_.concurrency_hint()));
-}
-
-void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s)
-{
- mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
- registered_descriptors_.free(s);
-}
-
-void epoll_reactor::do_add_timer_queue(timer_queue_base& queue)
-{
- mutex::scoped_lock lock(mutex_);
- timer_queues_.insert(&queue);
-}
-
-void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue)
-{
- mutex::scoped_lock lock(mutex_);
- timer_queues_.erase(&queue);
-}
-
-void epoll_reactor::update_timeout()
-{
-#if defined(ASIO_HAS_TIMERFD)
- if (timer_fd_ != -1)
- {
- itimerspec new_timeout;
- itimerspec old_timeout;
- int flags = get_timeout(new_timeout);
- timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout);
- return;
- }
-#endif // defined(ASIO_HAS_TIMERFD)
- interrupt();
-}
-
-int epoll_reactor::get_timeout(int msec)
-{
- // By default we will wait no longer than 5 minutes. This will ensure that
- // any changes to the system clock are detected after no longer than this.
- const int max_msec = 5 * 60 * 1000;
- return timer_queues_.wait_duration_msec(
- (msec < 0 || max_msec < msec) ? max_msec : msec);
-}
-
-#if defined(ASIO_HAS_TIMERFD)
-int epoll_reactor::get_timeout(itimerspec& ts)
-{
- ts.it_interval.tv_sec = 0;
- ts.it_interval.tv_nsec = 0;
-
- long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
- ts.it_value.tv_sec = usec / 1000000;
- ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1;
-
- return usec ? 0 : TFD_TIMER_ABSTIME;
-}
-#endif // defined(ASIO_HAS_TIMERFD)
-
-struct epoll_reactor::perform_io_cleanup_on_block_exit
-{
- explicit perform_io_cleanup_on_block_exit(epoll_reactor* r)
- : reactor_(r), first_op_(0)
- {
- }
-
- ~perform_io_cleanup_on_block_exit()
- {
- if (first_op_)
- {
- // Post the remaining completed operations for invocation.
- if (!ops_.empty())
- reactor_->scheduler_.post_deferred_completions(ops_);
-
- // A user-initiated operation has completed, but there's no need to
- // explicitly call work_finished() here. Instead, we'll take advantage of
- // the fact that the scheduler will call work_finished() once we return.
- }
- else
- {
- // No user-initiated operations have completed, so we need to compensate
- // for the work_finished() call that the scheduler will make once this
- // operation returns.
- reactor_->scheduler_.compensating_work_started();
- }
- }
-
- epoll_reactor* reactor_;
- op_queue<operation> ops_;
- operation* first_op_;
-};
-
-epoll_reactor::descriptor_state::descriptor_state(bool locking)
- : operation(&epoll_reactor::descriptor_state::do_complete),
- mutex_(locking)
-{
-}
-
-operation* epoll_reactor::descriptor_state::perform_io(uint32_t events)
-{
- mutex_.lock();
- perform_io_cleanup_on_block_exit io_cleanup(reactor_);
- mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock);
-
- // Exception operations must be processed first to ensure that any
- // out-of-band data is read before normal data.
- static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI };
- for (int j = max_ops - 1; j >= 0; --j)
- {
- if (events & (flag[j] | EPOLLERR | EPOLLHUP))
- {
- try_speculative_[j] = true;
- while (reactor_op* op = op_queue_[j].front())
- {
- if (reactor_op::status status = op->perform())
- {
- op_queue_[j].pop();
- io_cleanup.ops_.push(op);
- if (status == reactor_op::done_and_exhausted)
- {
- try_speculative_[j] = false;
- break;
- }
- }
- else
- break;
- }
- }
- }
-
- // The first operation will be returned for completion now. The others will
- // be posted for later by the io_cleanup object's destructor.
- io_cleanup.first_op_ = io_cleanup.ops_.front();
- io_cleanup.ops_.pop();
- return io_cleanup.first_op_;
-}
-
-void epoll_reactor::descriptor_state::do_complete(
- void* owner, operation* base,
- const asio::error_code& ec, std::size_t bytes_transferred)
-{
- if (owner)
- {
- descriptor_state* descriptor_data = static_cast<descriptor_state*>(base);
- uint32_t events = static_cast<uint32_t>(bytes_transferred);
- if (operation* op = descriptor_data->perform_io(events))
- {
- op->complete(owner, ec, 0);
- }
- }
-}
-
-} // namespace detail
-} // namespace asio
-
-#include "asio/detail/pop_options.hpp"
-
-#endif // defined(ASIO_HAS_EPOLL)
-
-#endif // ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP