Chris@16: //
Chris@16: // detail/impl/kqueue_reactor.ipp
Chris@16: // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Chris@16: //
Chris@101: // Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
Chris@16: // Copyright (c) 2005 Stefan Arentz (stefan at soze dot com)
Chris@16: //
Chris@16: // Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16: // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: //
Chris@16: 
Chris@16: #ifndef BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
Chris@16: #define BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP
Chris@16: 
Chris@16: #if defined(_MSC_VER) && (_MSC_VER >= 1200)
Chris@16: # pragma once
Chris@16: #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
Chris@16: 
Chris@16: #include <boost/asio/detail/config.hpp>
Chris@16: 
Chris@16: #if defined(BOOST_ASIO_HAS_KQUEUE)
Chris@16: 
Chris@16: #include <boost/asio/detail/kqueue_reactor.hpp>
Chris@16: #include <boost/asio/detail/throw_error.hpp>
Chris@16: #include <boost/asio/error.hpp>
Chris@16: 
Chris@16: #include <boost/asio/detail/push_options.hpp>
Chris@16: 
Chris@16: #if defined(__NetBSD__)
Chris@16: # define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
Chris@16:     EV_SET(ev, ident, filt, flags, fflags, data, \
Chris@16:       reinterpret_cast<intptr_t>(static_cast<void*>(udata)))
Chris@16: #else
Chris@16: # define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \
Chris@16:     EV_SET(ev, ident, filt, flags, fflags, data, udata)
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost {
Chris@16: namespace asio {
Chris@16: namespace detail {
Chris@16: 
Chris@16: kqueue_reactor::kqueue_reactor(boost::asio::io_service& io_service)
Chris@16:   : boost::asio::detail::service_base<kqueue_reactor>(io_service),
Chris@16:     io_service_(use_service<io_service_impl>(io_service)),
Chris@16:     mutex_(),
Chris@16:     kqueue_fd_(do_kqueue_create()),
Chris@16:     interrupter_(),
Chris@16:     shutdown_(false)
Chris@16: {
Chris@101:   struct kevent events[1];
Chris@101:   BOOST_ASIO_KQUEUE_EV_SET(&events[0], interrupter_.read_descriptor(),
Chris@101:       EVFILT_READ, EV_ADD, 0, 0, &interrupter_);
Chris@101:   if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1)
Chris@101:   {
Chris@101:     boost::system::error_code error(errno,
Chris@101:         boost::asio::error::get_system_category());
Chris@101:     boost::asio::detail::throw_error(error);
Chris@101:   }
Chris@16: }
Chris@16: 
Chris@16: kqueue_reactor::~kqueue_reactor()
Chris@16: {
Chris@16:   close(kqueue_fd_);
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::shutdown_service()
Chris@16: {
Chris@16:   mutex::scoped_lock lock(mutex_);
Chris@16:   shutdown_ = true;
Chris@16:   lock.unlock();
Chris@16: 
Chris@16:   op_queue<operation> ops;
Chris@16: 
Chris@16:   while (descriptor_state* state = registered_descriptors_.first())
Chris@16:   {
Chris@16:     for (int i = 0; i < max_ops; ++i)
Chris@16:       ops.push(state->op_queue_[i]);
Chris@16:     state->shutdown_ = true;
Chris@16:     registered_descriptors_.free(state);
Chris@16:   }
Chris@16: 
Chris@16:   timer_queues_.get_all_timers(ops);
Chris@16: 
Chris@16:   io_service_.abandon_operations(ops);
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::fork_service(boost::asio::io_service::fork_event fork_ev)
Chris@16: {
Chris@16:   if (fork_ev == boost::asio::io_service::fork_child)
Chris@16:   {
Chris@16:     // The kqueue descriptor is automatically closed in the child.
Chris@16:     kqueue_fd_ = -1;
Chris@16:     kqueue_fd_ = do_kqueue_create();
Chris@16: 
Chris@16:     interrupter_.recreate();
Chris@16: 
Chris@101:     struct kevent events[2];
Chris@101:     BOOST_ASIO_KQUEUE_EV_SET(&events[0], interrupter_.read_descriptor(),
Chris@101:         EVFILT_READ, EV_ADD, 0, 0, &interrupter_);
Chris@101:     if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1)
Chris@101:     {
Chris@101:       boost::system::error_code ec(errno,
Chris@101:           boost::asio::error::get_system_category());
Chris@101:       boost::asio::detail::throw_error(ec, "kqueue interrupter registration");
Chris@101:     }
Chris@101: 
Chris@16:     // Re-register all descriptors with kqueue.
Chris@16:     mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
Chris@16:     for (descriptor_state* state = registered_descriptors_.first();
Chris@16:         state != 0; state = state->next_)
Chris@16:     {
Chris@101:       if (state->num_kevents_ > 0)
Chris@101:       {
Chris@101:         BOOST_ASIO_KQUEUE_EV_SET(&events[0], state->descriptor_,
Chris@16:             EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, state);
Chris@101:         BOOST_ASIO_KQUEUE_EV_SET(&events[1], state->descriptor_,
Chris@16:             EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, state);
Chris@101:         if (::kevent(kqueue_fd_, events, state->num_kevents_, 0, 0, 0) == -1)
Chris@101:         {
Chris@101:           boost::system::error_code ec(errno,
Chris@101:               boost::asio::error::get_system_category());
Chris@101:           boost::asio::detail::throw_error(ec, "kqueue re-registration");
Chris@101:         }
Chris@16:       }
Chris@16:     }
Chris@16:   }
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::init_task()
Chris@16: {
Chris@16:   io_service_.init_task();
Chris@16: }
Chris@16: 
Chris@16: int kqueue_reactor::register_descriptor(socket_type descriptor,
Chris@16:     kqueue_reactor::per_descriptor_data& descriptor_data)
Chris@16: {
Chris@16:   descriptor_data = allocate_descriptor_state();
Chris@16: 
Chris@16:   mutex::scoped_lock lock(descriptor_data->mutex_);
Chris@16: 
Chris@16:   descriptor_data->descriptor_ = descriptor;
Chris@101:   descriptor_data->num_kevents_ = 0;
Chris@16:   descriptor_data->shutdown_ = false;
Chris@16: 
Chris@16:   return 0;
Chris@16: }
Chris@16: 
Chris@16: int kqueue_reactor::register_internal_descriptor(
Chris@16:     int op_type, socket_type descriptor,
Chris@16:     kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op)
Chris@16: {
Chris@16:   descriptor_data = allocate_descriptor_state();
Chris@16: 
Chris@16:   mutex::scoped_lock lock(descriptor_data->mutex_);
Chris@16: 
Chris@16:   descriptor_data->descriptor_ = descriptor;
Chris@101:   descriptor_data->num_kevents_ = 1;
Chris@16:   descriptor_data->shutdown_ = false;
Chris@16:   descriptor_data->op_queue_[op_type].push(op);
Chris@16: 
Chris@101:   struct kevent events[1];
Chris@101:   BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
Chris@101:       EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
Chris@101:   if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1)
Chris@101:     return errno;
Chris@16: 
Chris@16:   return 0;
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::move_descriptor(socket_type,
Chris@16:     kqueue_reactor::per_descriptor_data& target_descriptor_data,
Chris@16:     kqueue_reactor::per_descriptor_data& source_descriptor_data)
Chris@16: {
Chris@16:   target_descriptor_data = source_descriptor_data;
Chris@16:   source_descriptor_data = 0;
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::start_op(int op_type, socket_type descriptor,
Chris@16:     kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op,
Chris@16:     bool is_continuation, bool allow_speculative)
Chris@16: {
Chris@16:   if (!descriptor_data)
Chris@16:   {
Chris@16:     op->ec_ = boost::asio::error::bad_descriptor;
Chris@16:     post_immediate_completion(op, is_continuation);
Chris@16:     return;
Chris@16:   }
Chris@16: 
Chris@16:   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
Chris@16: 
Chris@16:   if (descriptor_data->shutdown_)
Chris@16:   {
Chris@16:     post_immediate_completion(op, is_continuation);
Chris@16:     return;
Chris@16:   }
Chris@16: 
Chris@101:   if (descriptor_data->op_queue_[op_type].empty())
Chris@16:   {
Chris@101:     static const int num_kevents[max_ops] = { 1, 2, 1 };
Chris@101: 
Chris@101:     if (allow_speculative
Chris@101:         && (op_type != read_op
Chris@101:           || descriptor_data->op_queue_[except_op].empty()))
Chris@16:     {
Chris@101:       if (op->perform())
Chris@16:       {
Chris@101:         descriptor_lock.unlock();
Chris@101:         io_service_.post_immediate_completion(op, is_continuation);
Chris@101:         return;
Chris@101:       }
Chris@101: 
Chris@101:       if (descriptor_data->num_kevents_ < num_kevents[op_type])
Chris@101:       {
Chris@101:         struct kevent events[2];
Chris@101:         BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
Chris@101:             EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
Chris@101:         BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE,
Chris@101:             EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
Chris@101:         if (::kevent(kqueue_fd_, events, num_kevents[op_type], 0, 0, 0) != -1)
Chris@16:         {
Chris@101:           descriptor_data->num_kevents_ = num_kevents[op_type];
Chris@101:         }
Chris@101:         else
Chris@101:         {
Chris@101:           op->ec_ = boost::system::error_code(errno,
Chris@101:               boost::asio::error::get_system_category());
Chris@16:           io_service_.post_immediate_completion(op, is_continuation);
Chris@16:           return;
Chris@16:         }
Chris@16:       }
Chris@16:     }
Chris@101:     else
Chris@101:     {
Chris@101:       if (descriptor_data->num_kevents_ < num_kevents[op_type])
Chris@101:         descriptor_data->num_kevents_ = num_kevents[op_type];
Chris@101: 
Chris@101:       struct kevent events[2];
Chris@101:       BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ,
Chris@101:           EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
Chris@101:       BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE,
Chris@101:           EV_ADD | EV_CLEAR, 0, 0, descriptor_data);
Chris@101:       ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0);
Chris@101:     }
Chris@16:   }
Chris@16: 
Chris@16:   descriptor_data->op_queue_[op_type].push(op);
Chris@16:   io_service_.work_started();
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::cancel_ops(socket_type,
Chris@16:     kqueue_reactor::per_descriptor_data& descriptor_data)
Chris@16: {
Chris@16:   if (!descriptor_data)
Chris@16:     return;
Chris@16: 
Chris@16:   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
Chris@16: 
Chris@16:   op_queue<operation> ops;
Chris@16:   for (int i = 0; i < max_ops; ++i)
Chris@16:   {
Chris@16:     while (reactor_op* op = descriptor_data->op_queue_[i].front())
Chris@16:     {
Chris@16:       op->ec_ = boost::asio::error::operation_aborted;
Chris@16:       descriptor_data->op_queue_[i].pop();
Chris@16:       ops.push(op);
Chris@16:     }
Chris@16:   }
Chris@16: 
Chris@16:   descriptor_lock.unlock();
Chris@16: 
Chris@16:   io_service_.post_deferred_completions(ops);
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::deregister_descriptor(socket_type descriptor,
Chris@16:     kqueue_reactor::per_descriptor_data& descriptor_data, bool closing)
Chris@16: {
Chris@16:   if (!descriptor_data)
Chris@16:     return;
Chris@16: 
Chris@16:   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
Chris@16: 
Chris@16:   if (!descriptor_data->shutdown_)
Chris@16:   {
Chris@16:     if (closing)
Chris@16:     {
Chris@16:       // The descriptor will be automatically removed from the kqueue when it
Chris@16:       // is closed.
Chris@16:     }
Chris@16:     else
Chris@16:     {
Chris@16:       struct kevent events[2];
Chris@16:       BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor,
Chris@16:           EVFILT_READ, EV_DELETE, 0, 0, 0);
Chris@16:       BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor,
Chris@16:           EVFILT_WRITE, EV_DELETE, 0, 0, 0);
Chris@101:       ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0);
Chris@16:     }
Chris@16: 
Chris@16:     op_queue<operation> ops;
Chris@16:     for (int i = 0; i < max_ops; ++i)
Chris@16:     {
Chris@16:       while (reactor_op* op = descriptor_data->op_queue_[i].front())
Chris@16:       {
Chris@16:         op->ec_ = boost::asio::error::operation_aborted;
Chris@16:         descriptor_data->op_queue_[i].pop();
Chris@16:         ops.push(op);
Chris@16:       }
Chris@16:     }
Chris@16: 
Chris@16:     descriptor_data->descriptor_ = -1;
Chris@16:     descriptor_data->shutdown_ = true;
Chris@16: 
Chris@16:     descriptor_lock.unlock();
Chris@16: 
Chris@16:     free_descriptor_state(descriptor_data);
Chris@16:     descriptor_data = 0;
Chris@16: 
Chris@16:     io_service_.post_deferred_completions(ops);
Chris@16:   }
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::deregister_internal_descriptor(socket_type descriptor,
Chris@16:     kqueue_reactor::per_descriptor_data& descriptor_data)
Chris@16: {
Chris@16:   if (!descriptor_data)
Chris@16:     return;
Chris@16: 
Chris@16:   mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
Chris@16: 
Chris@16:   if (!descriptor_data->shutdown_)
Chris@16:   {
Chris@16:     struct kevent events[2];
Chris@16:     BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor,
Chris@16:         EVFILT_READ, EV_DELETE, 0, 0, 0);
Chris@16:     BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor,
Chris@16:         EVFILT_WRITE, EV_DELETE, 0, 0, 0);
Chris@101:     ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0);
Chris@16: 
Chris@16:     op_queue<operation> ops;
Chris@16:     for (int i = 0; i < max_ops; ++i)
Chris@16:       ops.push(descriptor_data->op_queue_[i]);
Chris@16: 
Chris@16:     descriptor_data->descriptor_ = -1;
Chris@16:     descriptor_data->shutdown_ = true;
Chris@16: 
Chris@16:     descriptor_lock.unlock();
Chris@16: 
Chris@16:     free_descriptor_state(descriptor_data);
Chris@16:     descriptor_data = 0;
Chris@16:   }
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::run(bool block, op_queue<operation>& ops)
Chris@16: {
Chris@16:   mutex::scoped_lock lock(mutex_);
Chris@16: 
Chris@16:   // Determine how long to block while waiting for events.
Chris@16:   timespec timeout_buf = { 0, 0 };
Chris@16:   timespec* timeout = block ? get_timeout(timeout_buf) : &timeout_buf;
Chris@16: 
Chris@16:   lock.unlock();
Chris@16: 
Chris@16:   // Block on the kqueue descriptor.
Chris@16:   struct kevent events[128];
Chris@16:   int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout);
Chris@16: 
Chris@16:   // Dispatch the waiting events.
Chris@16:   for (int i = 0; i < num_events; ++i)
Chris@16:   {
Chris@16:     void* ptr = reinterpret_cast<void*>(events[i].udata);
Chris@16:     if (ptr == &interrupter_)
Chris@16:     {
Chris@101:       interrupter_.reset();
Chris@16:     }
Chris@16:     else
Chris@16:     {
Chris@16:       descriptor_state* descriptor_data = static_cast<descriptor_state*>(ptr);
Chris@16:       mutex::scoped_lock descriptor_lock(descriptor_data->mutex_);
Chris@16: 
Chris@101:       if (events[i].filter == EVFILT_WRITE
Chris@101:           && descriptor_data->num_kevents_ == 2
Chris@101:           && descriptor_data->op_queue_[write_op].empty())
Chris@101:       {
Chris@101:         // Some descriptor types, like serial ports, don't seem to support
Chris@101:         // EV_CLEAR with EVFILT_WRITE. Since we have no pending write
Chris@101:         // operations we'll remove the EVFILT_WRITE registration here so that
Chris@101:         // we don't end up in a tight spin.
Chris@101:         struct kevent delete_events[1];
Chris@101:         BOOST_ASIO_KQUEUE_EV_SET(&delete_events[0],
Chris@101:             descriptor_data->descriptor_, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
Chris@101:         ::kevent(kqueue_fd_, delete_events, 1, 0, 0, 0);
Chris@101:         descriptor_data->num_kevents_ = 1;
Chris@101:       }
Chris@101: 
Chris@16:       // Exception operations must be processed first to ensure that any
Chris@16:       // out-of-band data is read before normal data.
Chris@16: #if defined(__NetBSD__)
Chris@16:       static const unsigned int filter[max_ops] =
Chris@16: #else
Chris@16:       static const int filter[max_ops] =
Chris@16: #endif
Chris@16:         { EVFILT_READ, EVFILT_WRITE, EVFILT_READ };
Chris@16:       for (int j = max_ops - 1; j >= 0; --j)
Chris@16:       {
Chris@16:         if (events[i].filter == filter[j])
Chris@16:         {
Chris@16:           if (j != except_op || events[i].flags & EV_OOBAND)
Chris@16:           {
Chris@16:             while (reactor_op* op = descriptor_data->op_queue_[j].front())
Chris@16:             {
Chris@16:               if (events[i].flags & EV_ERROR)
Chris@16:               {
Chris@16:                 op->ec_ = boost::system::error_code(
Chris@16:                     static_cast<int>(events[i].data),
Chris@16:                     boost::asio::error::get_system_category());
Chris@16:                 descriptor_data->op_queue_[j].pop();
Chris@16:                 ops.push(op);
Chris@16:               }
Chris@16:               if (op->perform())
Chris@16:               {
Chris@16:                 descriptor_data->op_queue_[j].pop();
Chris@16:                 ops.push(op);
Chris@16:               }
Chris@16:               else
Chris@16:                 break;
Chris@16:             }
Chris@16:           }
Chris@16:         }
Chris@16:       }
Chris@16:     }
Chris@16:   }
Chris@16: 
Chris@16:   lock.lock();
Chris@16:   timer_queues_.get_ready_timers(ops);
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::interrupt()
Chris@16: {
Chris@101:   interrupter_.interrupt();
Chris@16: }
Chris@16: 
Chris@16: int kqueue_reactor::do_kqueue_create()
Chris@16: {
Chris@16:   int fd = ::kqueue();
Chris@16:   if (fd == -1)
Chris@16:   {
Chris@16:     boost::system::error_code ec(errno,
Chris@16:         boost::asio::error::get_system_category());
Chris@16:     boost::asio::detail::throw_error(ec, "kqueue");
Chris@16:   }
Chris@16:   return fd;
Chris@16: }
Chris@16: 
Chris@16: kqueue_reactor::descriptor_state* kqueue_reactor::allocate_descriptor_state()
Chris@16: {
Chris@16:   mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
Chris@16:   return registered_descriptors_.alloc();
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::free_descriptor_state(kqueue_reactor::descriptor_state* s)
Chris@16: {
Chris@16:   mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_);
Chris@16:   registered_descriptors_.free(s);
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::do_add_timer_queue(timer_queue_base& queue)
Chris@16: {
Chris@16:   mutex::scoped_lock lock(mutex_);
Chris@16:   timer_queues_.insert(&queue);
Chris@16: }
Chris@16: 
Chris@16: void kqueue_reactor::do_remove_timer_queue(timer_queue_base& queue)
Chris@16: {
Chris@16:   mutex::scoped_lock lock(mutex_);
Chris@16:   timer_queues_.erase(&queue);
Chris@16: }
Chris@16: 
Chris@16: timespec* kqueue_reactor::get_timeout(timespec& ts)
Chris@16: {
Chris@16:   // By default we will wait no longer than 5 minutes. This will ensure that
Chris@16:   // any changes to the system clock are detected after no longer than this.
Chris@16:   long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000);
Chris@16:   ts.tv_sec = usec / 1000000;
Chris@16:   ts.tv_nsec = (usec % 1000000) * 1000;
Chris@16:   return &ts;
Chris@16: }
Chris@16: 
Chris@16: } // namespace detail
Chris@16: } // namespace asio
Chris@16: } // namespace boost
Chris@16: 
Chris@16: #undef BOOST_ASIO_KQUEUE_EV_SET
Chris@16: 
Chris@16: #include <boost/asio/detail/pop_options.hpp>
Chris@16: 
Chris@16: #endif // defined(BOOST_ASIO_HAS_KQUEUE)
Chris@16: 
Chris@16: #endif // BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP