passenger 6.0.6 → 6.0.22

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/select_reactor.ipp

@@ -2,7 +2,7 @@
 // detail/impl/select_reactor.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -28,6 +28,12 @@
 #include <boost/asio/detail/signal_blocker.hpp>
 #include <boost/asio/detail/socket_ops.hpp>
 
+#if defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/win_iocp_io_context.hpp>
+#else // defined(BOOST_ASIO_HAS_IOCP)
+# include <boost/asio/detail/scheduler.hpp>
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -61,6 +67,7 @@ select_reactor::select_reactor(boost::asio::execution_context& ctx)
 #if defined(BOOST_ASIO_HAS_IOCP)
     stop_thread_(false),
     thread_(0),
+    restart_reactor_(this),
 #endif // defined(BOOST_ASIO_HAS_IOCP)
     shutdown_(false)
 {
@@ -81,13 +88,14 @@ void select_reactor::shutdown()
   shutdown_ = true;
 #if defined(BOOST_ASIO_HAS_IOCP)
   stop_thread_ = true;
+  if (thread_)
+    interrupter_.interrupt();
 #endif // defined(BOOST_ASIO_HAS_IOCP)
   lock.unlock();
 
 #if defined(BOOST_ASIO_HAS_IOCP)
   if (thread_)
   {
-    interrupter_.interrupt();
     thread_->join();
     delete thread_;
     thread_ = 0;
@@ -107,8 +115,12 @@ void select_reactor::shutdown()
 void select_reactor::notify_fork(
     boost::asio::execution_context::fork_event fork_ev)
 {
+#if defined(BOOST_ASIO_HAS_IOCP)
+  (void)fork_ev;
+#else // defined(BOOST_ASIO_HAS_IOCP)
   if (fork_ev == boost::asio::execution_context::fork_child)
     interrupter_.recreate();
+#endif // defined(BOOST_ASIO_HAS_IOCP)
 }
 
 void select_reactor::init_task()
@@ -140,15 +152,23 @@ void select_reactor::move_descriptor(socket_type,
 {
 }
 
+void select_reactor::call_post_immediate_completion(
+    operation* op, bool is_continuation, const void* self)
+{
+  static_cast<const select_reactor*>(self)->post_immediate_completion(
+      op, is_continuation);
+}
+
 void select_reactor::start_op(int op_type, socket_type descriptor,
-    select_reactor::per_descriptor_data&, reactor_op* op,
-    bool is_continuation, bool)
+    select_reactor::per_descriptor_data&, reactor_op* op, bool is_continuation,
+    bool, void (*on_immediate)(operation*, bool, const void*),
+    const void* immediate_arg)
 {
   boost::asio::detail::mutex::scoped_lock lock(mutex_);
 
   if (shutdown_)
   {
-    post_immediate_completion(op, is_continuation);
+    on_immediate(op, is_continuation, immediate_arg);
     return;
   }
 
@@ -165,6 +185,19 @@ void select_reactor::cancel_ops(socket_type descriptor,
   cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted);
 }
 
+void select_reactor::cancel_ops_by_key(socket_type descriptor,
+    select_reactor::per_descriptor_data&,
+    int op_type, void* cancellation_key)
+{
+  boost::asio::detail::mutex::scoped_lock lock(mutex_);
+  op_queue<operation> ops;
+  bool need_interrupt = op_queue_[op_type].cancel_operations_by_key(
+      descriptor, ops, cancellation_key, boost::asio::error::operation_aborted);
+  scheduler_.post_deferred_completions(ops);
+  if (need_interrupt)
+    interrupter_.interrupt();
+}
+
 void select_reactor::deregister_descriptor(socket_type descriptor,
     select_reactor::per_descriptor_data&, bool)
 {
@@ -240,7 +273,16 @@ void select_reactor::run(long usec, op_queue<operation>& ops)
   // Reset the interrupter.
   if (retval > 0 && fd_sets_[read_op].is_set(interrupter_.read_descriptor()))
   {
-    interrupter_.reset();
+    if (!interrupter_.reset())
+    {
+      lock.lock();
+#if defined(BOOST_ASIO_HAS_IOCP)
+      stop_thread_ = true;
+      scheduler_.post_immediate_completion(&restart_reactor_, false);
+#else // defined(BOOST_ASIO_HAS_IOCP)
+      interrupter_.recreate();
+#endif // defined(BOOST_ASIO_HAS_IOCP)
+    }
     --retval;
   }
 
@@ -276,11 +318,36 @@ void select_reactor::run_thread()
   {
     lock.unlock();
     op_queue<operation> ops;
-    run(true, ops);
+    run(-1, ops);
     scheduler_.post_deferred_completions(ops);
     lock.lock();
   }
 }
+
+void select_reactor::restart_reactor::do_complete(void* owner, operation* base,
+    const boost::system::error_code& /*ec*/, std::size_t /*bytes_transferred*/)
+{
+  if (owner)
+  {
+    select_reactor* reactor = static_cast<restart_reactor*>(base)->reactor_;
+
+    if (reactor->thread_)
+    {
+      reactor->thread_->join();
+      delete reactor->thread_;
+      reactor->thread_ = 0;
+    }
+
+    boost::asio::detail::mutex::scoped_lock lock(reactor->mutex_);
+    reactor->interrupter_.recreate();
+    reactor->stop_thread_ = false;
+    lock.unlock();
+
+    boost::asio::detail::signal_blocker sb;
+    reactor->thread_ =
+      new boost::asio::detail::thread(thread_function(reactor));
+  }
+}
 #endif // defined(BOOST_ASIO_HAS_IOCP)
 
 void select_reactor::do_add_timer_queue(timer_queue_base& queue)

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/service_registry.hpp

@@ -2,7 +2,7 @@
 // detail/impl/service_registry.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -65,8 +65,7 @@ inline void service_registry::init_key(
 #if !defined(BOOST_ASIO_NO_TYPEID)
 template <typename Service>
 void service_registry::init_key(execution_context::service::key& key,
-    typename enable_if<
-      is_base_of<typename Service::key_type, Service>::value>::type*)
+    enable_if_t<is_base_of<typename Service::key_type, Service>::value>*)
 {
   key.type_info_ = &typeid(typeid_wrapper<Service>);
   key.id_ = 0;

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/service_registry.ipp

@@ -2,7 +2,7 @@
 // detail/impl/service_registry.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)

data/src/cxx_supportlib/vendor-modified/boost/asio/detail/impl/signal_set_service.ipp

@@ -2,7 +2,7 @@
 // detail/impl/signal_set_service.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2024 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)
@@ -19,12 +19,17 @@
 
 #include <cstring>
 #include <stdexcept>
-#include <boost/asio/detail/reactor.hpp>
 #include <boost/asio/detail/signal_blocker.hpp>
 #include <boost/asio/detail/signal_set_service.hpp>
 #include <boost/asio/detail/static_mutex.hpp>
 #include <boost/asio/detail/throw_exception.hpp>
 
+#if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/io_uring_service.hpp>
+#else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+# include <boost/asio/detail/reactor.hpp>
+#endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+
 #include <boost/asio/detail/push_options.hpp>
 
 namespace boost {
@@ -50,12 +55,16 @@ struct signal_state
 
   // A count of the number of objects that are registered for each signal.
   std::size_t registration_count_[max_signal_number];
+
+  // The flags used for each registered signal.
+  signal_set_base::flags_t flags_[max_signal_number];
 };
 
 signal_state* get_signal_state()
 {
   static signal_state state = {
-    BOOST_ASIO_STATIC_MUTEX_INIT, -1, -1, false, 0, { 0 } };
+    BOOST_ASIO_STATIC_MUTEX_INIT, -1, -1, false, 0,
+    { 0 }, { signal_set_base::flags_t() } };
   return &state;
 }
 
@@ -86,11 +95,45 @@ void boost_asio_signal_handler(int signal_number)
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
-class signal_set_service::pipe_read_op : public reactor_op
+class signal_set_service::pipe_read_op :
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  public io_uring_operation
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  public reactor_op
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 {
 public:
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  pipe_read_op()
+    : io_uring_operation(boost::system::error_code(), &pipe_read_op::do_prepare,
+        &pipe_read_op::do_perform, pipe_read_op::do_complete)
+  {
+  }
+
+  static void do_prepare(io_uring_operation*, ::io_uring_sqe* sqe)
+  {
+    signal_state* state = get_signal_state();
+
+    int fd = state->read_descriptor_;
+    ::io_uring_prep_poll_add(sqe, fd, POLLIN);
+  }
+
+  static bool do_perform(io_uring_operation*, bool)
+  {
+    signal_state* state = get_signal_state();
+
+    int fd = state->read_descriptor_;
+    int signal_number = 0;
+    while (::read(fd, &signal_number, sizeof(int)) == sizeof(int))
+      if (signal_number >= 0 && signal_number < max_signal_number)
+        signal_set_service::deliver_signal(signal_number);
+
+    return false;
+  }
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   pipe_read_op()
-    : reactor_op(&pipe_read_op::do_perform, pipe_read_op::do_complete)
+    : reactor_op(boost::system::error_code(),
+        &pipe_read_op::do_perform, pipe_read_op::do_complete)
   {
   }
 
@@ -106,6 +149,7 @@ public:
 
     return not_done;
   }
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 
   static void do_complete(void* /*owner*/, operation* base,
       const boost::system::error_code& /*ec*/,
@@ -119,14 +163,17 @@ public:
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
 
-signal_set_service::signal_set_service(
-    boost::asio::io_context& io_context)
-  : service_base<signal_set_service>(io_context),
-    io_context_(boost::asio::use_service<io_context_impl>(io_context)),
+signal_set_service::signal_set_service(execution_context& context)
+  : execution_context_service_base<signal_set_service>(context),
+    scheduler_(boost::asio::use_service<scheduler_impl>(context)),
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
-    reactor_(boost::asio::use_service<reactor>(io_context)),
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+    io_uring_service_(boost::asio::use_service<io_uring_service>(context)),
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+    reactor_(boost::asio::use_service<reactor>(context)),
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -138,7 +185,11 @@ signal_set_service::signal_set_service(
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
   && !defined(__CYGWIN__)
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  io_uring_service_.init_task();
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   reactor_.init_task();
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -170,11 +221,10 @@ void signal_set_service::shutdown()
     }
   }
 
-  io_context_.abandon_operations(ops);
+  scheduler_.abandon_operations(ops);
 }
 
-void signal_set_service::notify_fork(
-    boost::asio::io_context::fork_event fork_ev)
+void signal_set_service::notify_fork(execution_context::fork_event fork_ev)
 {
 #if !defined(BOOST_ASIO_WINDOWS) \
   && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \
@@ -184,26 +234,38 @@ void signal_set_service::notify_fork(
 
   switch (fork_ev)
   {
-  case boost::asio::io_context::fork_prepare:
+  case execution_context::fork_prepare:
     {
       int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = true;
       lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+      (void)read_descriptor;
+      io_uring_service_.deregister_io_object(io_object_data_);
+      io_uring_service_.cleanup_io_object(io_object_data_);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
       reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_);
       reactor_.cleanup_descriptor_data(reactor_data_);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     }
     break;
-  case boost::asio::io_context::fork_parent:
+  case execution_context::fork_parent:
     if (state->fork_prepared_)
     {
       int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = false;
       lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+      (void)read_descriptor;
+      io_uring_service_.register_internal_io_object(io_object_data_,
+          io_uring_service::read_op, new pipe_read_op);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
       reactor_.register_internal_descriptor(reactor::read_op,
           read_descriptor, reactor_data_, new pipe_read_op);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     }
     break;
-  case boost::asio::io_context::fork_child:
+  case execution_context::fork_child:
     if (state->fork_prepared_)
     {
       boost::asio::detail::signal_blocker blocker;
@@ -212,8 +274,14 @@ void signal_set_service::notify_fork(
       int read_descriptor = state->read_descriptor_;
       state->fork_prepared_ = false;
       lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+      (void)read_descriptor;
+      io_uring_service_.register_internal_io_object(io_object_data_,
+          io_uring_service::read_op, new pipe_read_op);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
       reactor_.register_internal_descriptor(reactor::read_op,
           read_descriptor, reactor_data_, new pipe_read_op);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     }
     break;
   default:
@@ -243,8 +311,8 @@ void signal_set_service::destroy(
 }
 
 boost::system::error_code signal_set_service::add(
-    signal_set_service::implementation_type& impl,
-    int signal_number, boost::system::error_code& ec)
+    signal_set_service::implementation_type& impl, int signal_number,
+    signal_set_base::flags_t f, boost::system::error_code& ec)
 {
   // Check that the signal number is valid.
   if (signal_number < 0 || signal_number >= max_signal_number)
@@ -253,6 +321,15 @@ boost::system::error_code signal_set_service::add(
     return ec;
   }
 
+  // Check that the specified flags are supported.
+#if !defined(BOOST_ASIO_HAS_SIGACTION)
+  if (f != signal_set_base::flags::dont_care)
+  {
+    ec = boost::asio::error::operation_not_supported;
+    return ec;
+  }
+#endif // !defined(BOOST_ASIO_HAS_SIGACTION)
+
   signal_state* state = get_signal_state();
   static_mutex::scoped_lock lock(state->mutex_);
 
@@ -280,6 +357,8 @@ boost::system::error_code signal_set_service::add(
       memset(&sa, 0, sizeof(sa));
       sa.sa_handler = boost_asio_signal_handler;
       sigfillset(&sa.sa_mask);
+      if (f != signal_set_base::flags::dont_care)
+        sa.sa_flags = static_cast<int>(f);
       if (::sigaction(signal_number, &sa, 0) == -1)
 # else // defined(BOOST_ASIO_HAS_SIGACTION)
       if (::signal(signal_number, boost_asio_signal_handler) == SIG_ERR)
@@ -294,7 +373,39 @@ boost::system::error_code signal_set_service::add(
         delete new_registration;
         return ec;
       }
+# if defined(BOOST_ASIO_HAS_SIGACTION)
+      state->flags_[signal_number] = f;
+# endif // defined(BOOST_ASIO_HAS_SIGACTION)
     }
+# if defined(BOOST_ASIO_HAS_SIGACTION)
+    // Otherwise check to see if the flags have changed.
+    else if (f != signal_set_base::flags::dont_care)
+    {
+      if (f != state->flags_[signal_number])
+      {
+        using namespace std; // For memset.
+        if (state->flags_[signal_number] != signal_set_base::flags::dont_care)
+        {
+          ec = boost::asio::error::invalid_argument;
+          delete new_registration;
+          return ec;
+        }
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_handler = boost_asio_signal_handler;
+        sigfillset(&sa.sa_mask);
+        sa.sa_flags = static_cast<int>(f);
+        if (::sigaction(signal_number, &sa, 0) == -1)
+        {
+          ec = boost::system::error_code(errno,
+              boost::asio::error::get_system_category());
+          delete new_registration;
+          return ec;
+        }
+        state->flags_[signal_number] = f;
+      }
+    }
+# endif // defined(BOOST_ASIO_HAS_SIGACTION)
 #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
 
     // Record the new registration in the set.
@@ -363,6 +474,9 @@ boost::system::error_code signal_set_service::remove(
 # endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         return ec;
       }
+# if defined(BOOST_ASIO_HAS_SIGACTION)
+      state->flags_[signal_number] = signal_set_base::flags_t();
+# endif // defined(BOOST_ASIO_HAS_SIGACTION)
     }
 #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
 
@@ -417,6 +531,9 @@ boost::system::error_code signal_set_service::clear(
 # endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
         return ec;
       }
+# if defined(BOOST_ASIO_HAS_SIGACTION)
+      state->flags_[reg->signal_number_] = signal_set_base::flags_t();
+# endif // defined(BOOST_ASIO_HAS_SIGACTION)
     }
 #endif // defined(BOOST_ASIO_HAS_SIGNAL) || defined(BOOST_ASIO_HAS_SIGACTION)
 
@@ -442,7 +559,7 @@ boost::system::error_code signal_set_service::cancel(
     signal_set_service::implementation_type& impl,
     boost::system::error_code& ec)
 {
-  BOOST_ASIO_HANDLER_OPERATION((io_context_.context(),
+  BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(),
         "signal_set", &impl, 0, "cancel"));
 
   op_queue<operation> ops;
@@ -458,12 +575,39 @@ boost::system::error_code signal_set_service::cancel(
     }
   }
 
-  io_context_.post_deferred_completions(ops);
+  scheduler_.post_deferred_completions(ops);
 
   ec = boost::system::error_code();
   return ec;
 }
 
+void signal_set_service::cancel_ops_by_key(
+    signal_set_service::implementation_type& impl, void* cancellation_key)
+{
+  op_queue<operation> ops;
+  {
+    op_queue<signal_op> other_ops;
+    signal_state* state = get_signal_state();
+    static_mutex::scoped_lock lock(state->mutex_);
+
+    while (signal_op* op = impl.queue_.front())
+    {
+      impl.queue_.pop();
+      if (op->cancellation_key_ == cancellation_key)
+      {
+        op->ec_ = boost::asio::error::operation_aborted;
+        ops.push(op);
+      }
+      else
+        other_ops.push(op);
+    }
+
+    impl.queue_.push(other_ops);
+  }
+
+  scheduler_.post_deferred_completions(ops);
+}
+
 void signal_set_service::deliver_signal(int signal_number)
 {
   signal_state* state = get_signal_state();
@@ -494,7 +638,7 @@ void signal_set_service::deliver_signal(int signal_number)
       reg = reg->next_in_table_;
     }
 
-    service->io_context_.post_deferred_completions(ops);
+    service->scheduler_.post_deferred_completions(ops);
 
     service = service->next_;
   }
@@ -511,17 +655,17 @@ void signal_set_service::add_service(signal_set_service* service)
     open_descriptors();
 #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__)
 
-  // If an io_context object is thread-unsafe then it must be the only
-  // io_context used to create signal_set objects.
+  // If a scheduler_ object is thread-unsafe then it must be the only
+  // scheduler used to create signal_set objects.
   if (state->service_list_ != 0)
   {
     if (!BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
-          service->io_context_.concurrency_hint())
+          service->scheduler_.concurrency_hint())
         || !BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER,
-          state->service_list_->io_context_.concurrency_hint()))
+          state->service_list_->scheduler_.concurrency_hint()))
     {
       std::logic_error ex(
-          "Thread-unsafe io_context objects require "
+          "Thread-unsafe execution context objects require "
           "exclusive access to signal handling.");
       boost::asio::detail::throw_exception(ex);
     }
@@ -540,8 +684,14 @@ void signal_set_service::add_service(signal_set_service* service)
   // Register for pipe readiness notifications.
   int read_descriptor = state->read_descriptor_;
   lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+  (void)read_descriptor;
+  service->io_uring_service_.register_internal_io_object(
+      service->io_object_data_, io_uring_service::read_op, new pipe_read_op);
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
   service->reactor_.register_internal_descriptor(reactor::read_op,
       read_descriptor, service->reactor_data_, new pipe_read_op);
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -560,10 +710,17 @@ void signal_set_service::remove_service(signal_set_service* service)
     // Disable the pipe readiness notifications.
     int read_descriptor = state->read_descriptor_;
     lock.unlock();
+# if defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
+    (void)read_descriptor;
+    service->io_uring_service_.deregister_io_object(service->io_object_data_);
+    service->io_uring_service_.cleanup_io_object(service->io_object_data_);
+    lock.lock();
+# else // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
     service->reactor_.deregister_internal_descriptor(
         read_descriptor, service->reactor_data_);
     service->reactor_.cleanup_descriptor_data(service->reactor_data_);
     lock.lock();
+# endif // defined(BOOST_ASIO_HAS_IO_URING_AS_DEFAULT)
 #endif // !defined(BOOST_ASIO_WINDOWS)
        //   && !defined(BOOST_ASIO_WINDOWS_RUNTIME)
        //   && !defined(__CYGWIN__)
@@ -640,7 +797,7 @@ void signal_set_service::close_descriptors()
 void signal_set_service::start_wait_op(
     signal_set_service::implementation_type& impl, signal_op* op)
 {
-  io_context_.work_started();
+  scheduler_.work_started();
 
   signal_state* state = get_signal_state();
   static_mutex::scoped_lock lock(state->mutex_);
@@ -652,7 +809,7 @@ void signal_set_service::start_wait_op(
     {
       --reg->undelivered_;
       op->signal_number_ = reg->signal_number_;
-      io_context_.post_deferred_completion(op);
+      scheduler_.post_deferred_completion(op);
       return;
     }