Switch QuicServer to use QuicEventLoop instead of QuicEpollServer
This allows QuicServer to work on all platforms supported by QuicEventLoop, instead of being Linux-only.
PiperOrigin-RevId: 460286930
diff --git a/quiche/quic/bindings/quic_libevent.cc b/quiche/quic/bindings/quic_libevent.cc
index 668f441..996d70b 100644
--- a/quiche/quic/bindings/quic_libevent.cc
+++ b/quiche/quic/bindings/quic_libevent.cc
@@ -35,30 +35,33 @@
LibeventAlarm(LibeventQuicEventLoop* loop,
QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
: QuicAlarm(std::move(delegate)), clock_(loop->clock()) {
- evtimer_assign(
- &event_, loop->base(),
+ event_.reset(evtimer_new(
+ loop->base(),
[](evutil_socket_t, LibeventEventMask, void* arg) {
LibeventAlarm* self = reinterpret_cast<LibeventAlarm*>(arg);
self->Fire();
},
- this);
+ this));
}
- ~LibeventAlarm() { event_del(&event_); }
protected:
void SetImpl() override {
absl::Duration timeout =
absl::Microseconds((deadline() - clock_->Now()).ToMicroseconds());
timeval unix_time = absl::ToTimeval(timeout);
- event_add(&event_, &unix_time);
+ event_add(event_.get(), &unix_time);
}
- void CancelImpl() override { event_del(&event_); }
+ void CancelImpl() override { event_del(event_.get()); }
private:
- // While this decreases ABI portability, we use event inline, rather than
- // allocating it with event_new(), since this improves cache locality.
- event event_;
+ // While we inline `struct event` elsewhere, it is actually quite large, so
+ // doing that for the libevent-based QuicAlarm would cause it to not fit into
+ // the QuicConnectionArena.
+ struct EventDeleter {
+ void operator()(event* ev) { event_free(ev); }
+ };
+ std::unique_ptr<event, EventDeleter> event_;
QuicClock* clock_;
};
@@ -205,8 +208,9 @@
void operator()(event_config* config) { event_config_free(config); }
};
-std::unique_ptr<QuicEventLoop> QuicLibeventEventLoopFactory::Create(
- QuicClock* clock) {
+std::unique_ptr<LibeventQuicEventLoopWithOwnership>
+LibeventQuicEventLoopWithOwnership::Create(QuicClock* clock,
+ bool force_level_triggered) {
// Required for event_base_loopbreak() to actually work.
static int threads_initialized = []() {
#ifdef _WIN32
@@ -219,7 +223,7 @@
std::unique_ptr<event_config, LibeventConfigDeleter> config(
event_config_new());
- if (force_level_triggered_) {
+ if (force_level_triggered) {
// epoll and kqueue are the two only current libevent backends that support
// edge-triggered I/O.
event_config_avoid_method(config.get(), "epoll");
diff --git a/quiche/quic/bindings/quic_libevent.h b/quiche/quic/bindings/quic_libevent.h
index 5eabb45..d8aa493 100644
--- a/quiche/quic/bindings/quic_libevent.h
+++ b/quiche/quic/bindings/quic_libevent.h
@@ -109,6 +109,9 @@
: public LibeventLoop,
public LibeventQuicEventLoop {
public:
+ static std::unique_ptr<LibeventQuicEventLoopWithOwnership> Create(
+ QuicClock* clock, bool force_level_triggered = false);
+
// Takes ownership of |base|.
explicit LibeventQuicEventLoopWithOwnership(struct event_base* base,
QuicClock* clock)
@@ -134,7 +137,10 @@
return factory;
}
- std::unique_ptr<QuicEventLoop> Create(QuicClock* clock) override;
+ std::unique_ptr<QuicEventLoop> Create(QuicClock* clock) override {
+ return LibeventQuicEventLoopWithOwnership::Create(clock,
+ force_level_triggered_);
+ }
std::string GetName() const override { return name_; }
private:
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index c1c46f0..8b7add5 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -21,6 +21,8 @@
#include "quiche/quic/core/http/http_constants.h"
#include "quiche/quic/core/http/quic_spdy_client_stream.h"
#include "quiche/quic/core/http/web_transport_http3.h"
+#include "quiche/quic/core/io/quic_default_event_loop.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/quic_connection.h"
#include "quiche/quic/core/quic_constants.h"
#include "quiche/quic/core/quic_data_writer.h"
@@ -98,9 +100,11 @@
// Run all tests with the cross products of all versions.
struct TestParams {
TestParams(const ParsedQuicVersion& version, QuicTag congestion_control_tag,
+ QuicEventLoopFactory* event_loop,
int override_server_connection_id_length)
: version(version),
congestion_control_tag(congestion_control_tag),
+ event_loop(event_loop),
override_server_connection_id_length(
override_server_connection_id_length) {}
@@ -108,6 +112,7 @@
os << "{ version: " << ParsedQuicVersionToString(p.version);
os << " congestion_control_tag: "
<< QuicTagToString(p.congestion_control_tag)
+ << " event loop: " << p.event_loop->GetName()
<< " connection ID length: " << p.override_server_connection_id_length
<< " }";
return os;
@@ -115,6 +120,7 @@
ParsedQuicVersion version;
QuicTag congestion_control_tag;
+ QuicEventLoopFactory* event_loop;
int override_server_connection_id_length;
};
@@ -122,7 +128,8 @@
std::string PrintToString(const TestParams& p) {
std::string rv = absl::StrCat(
ParsedQuicVersionToString(p.version), "_",
- QuicTagToString(p.congestion_control_tag), "_",
+ QuicTagToString(p.congestion_control_tag), "_", p.event_loop->GetName(),
+ "_",
std::to_string((p.override_server_connection_id_length == -1)
? static_cast<int>(kQuicDefaultConnectionIdLength)
: p.override_server_connection_id_length));
@@ -148,12 +155,22 @@
// qQUIC as well.
if (connection_id_length == -1 || version.UsesTls()) {
params.push_back(TestParams(version, congestion_control_tag,
+ GetDefaultEventLoop(),
connection_id_length));
}
} // End of outer version loop.
} // End of congestion_control_tag loop.
} // End of connection_id_length loop.
+ // Only run every event loop implementation for one fixed configuration.
+ for (QuicEventLoopFactory* event_loop : GetAllSupportedEventLoops()) {
+ if (event_loop == GetDefaultEventLoop()) {
+ continue;
+ }
+ params.push_back(
+ TestParams(ParsedQuicVersion::RFCv1(), kTBBR, event_loop, -1));
+ }
+
return params;
}
diff --git a/quiche/quic/core/io/quic_default_event_loop.h b/quiche/quic/core/io/quic_default_event_loop.h
index 6315b76..6073a6e 100644
--- a/quiche/quic/core/io/quic_default_event_loop.h
+++ b/quiche/quic/core/io/quic_default_event_loop.h
@@ -8,14 +8,13 @@
#include <memory>
#include "quiche/quic/core/io/quic_event_loop.h"
-#include "quiche/quic/core/quic_clock.h"
namespace quic {
// Returns the default implementation of QuicheEventLoop. The embedders can
// override this using the platform API. The factory pointer returned is an
// unowned static variable.
-QUICHE_NO_EXPORT QuicEventLoopFactory* GetDefaultEventLoop(QuicClock* clock);
+QUICHE_NO_EXPORT QuicEventLoopFactory* GetDefaultEventLoop();
// Returns the factory objects for all event loops. This is particularly useful
// for the unit tests. The factory pointers returned are unowned static
diff --git a/quiche/quic/masque/masque_dispatcher.cc b/quiche/quic/masque/masque_dispatcher.cc
index d0440a6..32776ee 100644
--- a/quiche/quic/masque/masque_dispatcher.cc
+++ b/quiche/quic/masque/masque_dispatcher.cc
@@ -11,7 +11,7 @@
MasqueDispatcher::MasqueDispatcher(
MasqueMode masque_mode, const QuicConfig* config,
const QuicCryptoServerConfig* crypto_config,
- QuicVersionManager* version_manager, QuicEpollServer* epoll_server,
+ QuicVersionManager* version_manager, QuicEventLoop* event_loop,
std::unique_ptr<QuicConnectionHelperInterface> helper,
std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
std::unique_ptr<QuicAlarmFactory> alarm_factory,
@@ -22,7 +22,7 @@
std::move(alarm_factory), masque_server_backend,
expected_server_connection_id_length),
masque_mode_(masque_mode),
- epoll_server_(epoll_server),
+ event_loop_(event_loop),
masque_server_backend_(masque_server_backend) {}
std::unique_ptr<QuicSession> MasqueDispatcher::CreateQuicSession(
@@ -39,8 +39,8 @@
auto session = std::make_unique<MasqueServerSession>(
masque_mode_, config(), GetSupportedVersions(), connection, this,
- epoll_server_, session_helper(), crypto_config(),
- compressed_certs_cache(), masque_server_backend_);
+ event_loop_, session_helper(), crypto_config(), compressed_certs_cache(),
+ masque_server_backend_);
session->Initialize();
return session;
}
diff --git a/quiche/quic/masque/masque_dispatcher.h b/quiche/quic/masque/masque_dispatcher.h
index b5ef5bb..804d2e9 100644
--- a/quiche/quic/masque/masque_dispatcher.h
+++ b/quiche/quic/masque/masque_dispatcher.h
@@ -6,10 +6,10 @@
#define QUICHE_QUIC_MASQUE_MASQUE_DISPATCHER_H_
#include "absl/container/flat_hash_map.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/masque/masque_server_backend.h"
#include "quiche/quic/masque/masque_server_session.h"
#include "quiche/quic/masque/masque_utils.h"
-#include "quiche/quic/platform/api/quic_epoll.h"
#include "quiche/quic/platform/api/quic_export.h"
#include "quiche/quic/tools/quic_simple_dispatcher.h"
@@ -22,7 +22,7 @@
explicit MasqueDispatcher(
MasqueMode masque_mode, const QuicConfig* config,
const QuicCryptoServerConfig* crypto_config,
- QuicVersionManager* version_manager, QuicEpollServer* epoll_server,
+ QuicVersionManager* version_manager, QuicEventLoop* event_loop,
std::unique_ptr<QuicConnectionHelperInterface> helper,
std::unique_ptr<QuicCryptoServerStreamBase::Helper> session_helper,
std::unique_ptr<QuicAlarmFactory> alarm_factory,
@@ -42,7 +42,7 @@
private:
MasqueMode masque_mode_;
- QuicEpollServer* epoll_server_; // Unowned.
+ QuicEventLoop* event_loop_; // Unowned.
MasqueServerBackend* masque_server_backend_; // Unowned.
};
diff --git a/quiche/quic/masque/masque_epoll_server.cc b/quiche/quic/masque/masque_epoll_server.cc
index 1efc5e1..a67c507 100644
--- a/quiche/quic/masque/masque_epoll_server.cc
+++ b/quiche/quic/masque/masque_epoll_server.cc
@@ -4,7 +4,7 @@
#include "quiche/quic/masque/masque_epoll_server.h"
-#include "quiche/quic/core/quic_epoll_alarm_factory.h"
+#include "quiche/quic/core/quic_default_connection_helper.h"
#include "quiche/quic/masque/masque_dispatcher.h"
#include "quiche/quic/masque/masque_utils.h"
#include "quiche/quic/platform/api/quic_default_proof_providers.h"
@@ -22,12 +22,10 @@
QuicDispatcher* MasqueEpollServer::CreateQuicDispatcher() {
return new MasqueDispatcher(
masque_mode_, &config(), &crypto_config(), version_manager(),
- epoll_server(),
- std::make_unique<QuicEpollConnectionHelper>(epoll_server(),
- QuicAllocator::BUFFER_POOL),
+ event_loop(), std::make_unique<QuicDefaultConnectionHelper>(),
std::make_unique<QuicSimpleCryptoServerStreamHelper>(),
- std::make_unique<QuicEpollAlarmFactory>(epoll_server()),
- masque_server_backend_, expected_server_connection_id_length());
+ event_loop()->CreateAlarmFactory(), masque_server_backend_,
+ expected_server_connection_id_length());
}
} // namespace quic
diff --git a/quiche/quic/masque/masque_server_session.cc b/quiche/quic/masque/masque_server_session.cc
index 742b0c6..03fc326 100644
--- a/quiche/quic/masque/masque_server_session.cc
+++ b/quiche/quic/masque/masque_server_session.cc
@@ -9,11 +9,13 @@
#include <cstddef>
#include <limits>
+#include "absl/cleanup/cleanup.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "quiche/quic/core/http/spdy_utils.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/quic_data_reader.h"
#include "quiche/quic/core/quic_udp_socket.h"
#include "quiche/quic/tools/quic_url.h"
@@ -79,7 +81,7 @@
MasqueMode masque_mode, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicConnection* connection, QuicSession::Visitor* visitor,
- QuicEpollServer* epoll_server, QuicCryptoServerStreamBase::Helper* helper,
+ QuicEventLoop* event_loop, QuicCryptoServerStreamBase::Helper* helper,
const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
MasqueServerBackend* masque_server_backend)
@@ -87,7 +89,7 @@
helper, crypto_config, compressed_certs_cache,
masque_server_backend),
masque_server_backend_(masque_server_backend),
- epoll_server_(epoll_server),
+ event_loop_(event_loop),
masque_mode_(masque_mode) {
// Artificially increase the max packet length to 1350 to ensure we can fit
// QUIC packets inside DATAGRAM frames.
@@ -95,7 +97,7 @@
connection->SetMaxPacketLength(kDefaultMaxPacketSize);
masque_server_backend_->RegisterBackendClient(connection_id(), this);
- QUICHE_DCHECK_NE(epoll_server_, nullptr);
+ QUICHE_DCHECK_NE(event_loop_, nullptr);
}
void MasqueServerSession::OnMessageAcked(QuicMessageId message_id,
@@ -229,7 +231,11 @@
QUIC_DLOG(ERROR) << "Socket bind failed";
return CreateBackendErrorResponse("500", "Socket bind failed");
}
- epoll_server_->RegisterFDForRead(fd_wrapper.fd(), this);
+ if (!event_loop_->RegisterSocket(fd_wrapper.fd(), kSocketEventReadable,
+ this)) {
+ QUIC_DLOG(ERROR) << "Failed to register socket with the event loop";
+ return CreateBackendErrorResponse("500", "Registering socket failed");
+ }
QuicSpdyStream* stream =
static_cast<QuicSpdyStream*>(GetActiveStream(request_handler->stream_id()));
@@ -252,19 +258,11 @@
return response;
}
-void MasqueServerSession::OnRegistration(QuicEpollServer* /*eps*/,
- QuicUdpSocketFd fd, int event_mask) {
- QUIC_DVLOG(1) << "OnRegistration " << fd << " event_mask " << event_mask;
-}
-
-void MasqueServerSession::OnModification(QuicUdpSocketFd fd, int event_mask) {
- QUIC_DVLOG(1) << "OnModification " << fd << " event_mask " << event_mask;
-}
-
-void MasqueServerSession::OnEvent(QuicUdpSocketFd fd, QuicEpollEvent* event) {
- if ((event->in_events & EPOLLIN) == 0) {
- QUIC_DVLOG(1) << "Ignoring OnEvent fd " << fd << " event mask "
- << event->in_events;
+void MasqueServerSession::OnSocketEvent(QuicEventLoop* /*event_loop*/,
+ QuicUdpSocketFd fd,
+ QuicSocketEventMask events) {
+ if ((events & kSocketEventReadable) == 0) {
+ QUIC_DVLOG(1) << "Ignoring OnEvent fd " << fd << " event mask " << events;
return;
}
auto it = absl::c_find_if(connect_udp_server_states_,
@@ -272,16 +270,26 @@
return connect_udp.fd() == fd;
});
if (it == connect_udp_server_states_.end()) {
- QUIC_BUG(quic_bug_10974_1) << "Got unexpected event mask "
- << event->in_events << " on unknown fd " << fd;
+ QUIC_BUG(quic_bug_10974_1)
+ << "Got unexpected event mask " << events << " on unknown fd " << fd;
return;
}
+
+ auto rearm = absl::MakeCleanup([&]() {
+ if (!event_loop_->SupportsEdgeTriggered()) {
+ if (!event_loop_->RearmSocket(fd, kSocketEventReadable)) {
+ QUIC_BUG(MasqueServerSession_OnSocketEvent_Rearm)
+ << "Failed to re-arm socket " << fd << " for reading";
+ }
+ }
+ });
+
QuicSocketAddress expected_target_server_address =
it->target_server_address();
QUICHE_DCHECK(expected_target_server_address.IsInitialized());
- QUIC_DVLOG(1) << "Received readable event on fd " << fd << " (mask "
- << event->in_events << ") stream ID " << it->stream()->id()
- << " server " << expected_target_server_address;
+ QUIC_DVLOG(1) << "Received readable event on fd " << fd << " (mask " << events
+ << ") stream ID " << it->stream()->id() << " server "
+ << expected_target_server_address;
QuicUdpSocketApi socket_api;
BitMask64 packet_info_interested(QuicUdpPacketInfoBit::PEER_ADDRESS);
char packet_buffer[1 + kMaxIncomingPacketSize];
@@ -329,20 +337,6 @@
}
}
-void MasqueServerSession::OnUnregistration(QuicUdpSocketFd fd, bool replaced) {
- QUIC_DVLOG(1) << "OnUnregistration " << fd << " " << (replaced ? "" : "!")
- << " replaced";
-}
-
-void MasqueServerSession::OnShutdown(QuicEpollServer* /*eps*/,
- QuicUdpSocketFd fd) {
- QUIC_DVLOG(1) << "OnShutdown " << fd;
-}
-
-std::string MasqueServerSession::Name() const {
- return std::string("MasqueServerSession-") + connection_id().ToString();
-}
-
bool MasqueServerSession::OnSettingsFrame(const SettingsFrame& frame) {
QUIC_DLOG(INFO) << "Received SETTINGS: " << frame;
if (!QuicSimpleServerSession::OnSettingsFrame(frame)) {
@@ -377,7 +371,9 @@
}
QuicUdpSocketApi socket_api;
QUIC_DLOG(INFO) << "Closing fd " << fd_;
- masque_session_->epoll_server()->UnregisterFD(fd_);
+ if (!masque_session_->event_loop()->UnregisterSocket(fd_)) {
+ QUIC_DLOG(ERROR) << "Failed to unregister FD " << fd_;
+ }
socket_api.Destroy(fd_);
}
@@ -393,7 +389,9 @@
if (fd_ != kQuicInvalidSocketFd) {
QuicUdpSocketApi socket_api;
QUIC_DLOG(INFO) << "Closing fd " << fd_;
- masque_session_->epoll_server()->UnregisterFD(fd_);
+ if (!masque_session_->event_loop()->UnregisterSocket(fd_)) {
+ QUIC_DLOG(ERROR) << "Failed to unregister FD " << fd_;
+ }
socket_api.Destroy(fd_);
}
stream_ = other.stream_;
diff --git a/quiche/quic/masque/masque_server_session.h b/quiche/quic/masque/masque_server_session.h
index 59b33c2..d820137 100644
--- a/quiche/quic/masque/masque_server_session.h
+++ b/quiche/quic/masque/masque_server_session.h
@@ -5,11 +5,11 @@
#ifndef QUICHE_QUIC_MASQUE_MASQUE_SERVER_SESSION_H_
#define QUICHE_QUIC_MASQUE_MASQUE_SERVER_SESSION_H_
+#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/core/quic_udp_socket.h"
#include "quiche/quic/masque/masque_server_backend.h"
#include "quiche/quic/masque/masque_utils.h"
-#include "quiche/quic/platform/api/quic_epoll.h"
#include "quiche/quic/platform/api/quic_export.h"
#include "quiche/quic/tools/quic_simple_server_session.h"
@@ -19,13 +19,13 @@
class QUIC_NO_EXPORT MasqueServerSession
: public QuicSimpleServerSession,
public MasqueServerBackend::BackendClient,
- public QuicEpollCallbackInterface {
+ public QuicSocketEventListener {
public:
explicit MasqueServerSession(
MasqueMode masque_mode, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
QuicConnection* connection, QuicSession::Visitor* visitor,
- QuicEpollServer* epoll_server, QuicCryptoServerStreamBase::Helper* helper,
+ QuicEventLoop* event_loop, QuicCryptoServerStreamBase::Helper* helper,
const QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
MasqueServerBackend* masque_server_backend);
@@ -47,16 +47,11 @@
const spdy::Http2HeaderBlock& request_headers,
QuicSimpleServerBackend::RequestHandler* request_handler) override;
- // From QuicEpollCallbackInterface.
- void OnRegistration(QuicEpollServer* eps, QuicUdpSocketFd fd,
- int event_mask) override;
- void OnModification(QuicUdpSocketFd fd, int event_mask) override;
- void OnEvent(QuicUdpSocketFd fd, QuicEpollEvent* event) override;
- void OnUnregistration(QuicUdpSocketFd fd, bool replaced) override;
- void OnShutdown(QuicEpollServer* eps, QuicUdpSocketFd fd) override;
- std::string Name() const override;
+ // From QuicSocketEventListener.
+ void OnSocketEvent(QuicEventLoop* event_loop, QuicUdpSocketFd fd,
+ QuicSocketEventMask events) override;
- QuicEpollServer* epoll_server() const { return epoll_server_; }
+ QuicEventLoop* event_loop() const { return event_loop_; }
private:
// State that the MasqueServerSession keeps for each CONNECT-UDP request.
@@ -64,7 +59,7 @@
: public QuicSpdyStream::Http3DatagramVisitor {
public:
// ConnectUdpServerState takes ownership of |fd|. It will unregister it
- // from |epoll_server| and close the file descriptor when destructed.
+ // from |event_loop| and close the file descriptor when destructed.
explicit ConnectUdpServerState(
QuicSpdyStream* stream, const QuicSocketAddress& target_server_address,
QuicUdpSocketFd fd, MasqueServerSession* masque_session);
@@ -101,7 +96,7 @@
}
MasqueServerBackend* masque_server_backend_; // Unowned.
- QuicEpollServer* epoll_server_; // Unowned.
+ QuicEventLoop* event_loop_; // Unowned.
MasqueMode masque_mode_;
std::list<ConnectUdpServerState> connect_udp_server_states_;
bool masque_initialized_ = false;
diff --git a/quiche/quic/qbone/qbone_client_test.cc b/quiche/quic/qbone/qbone_client_test.cc
index 5fd7229..0e6d5eb 100644
--- a/quiche/quic/qbone/qbone_client_test.cc
+++ b/quiche/quic/qbone/qbone_client_test.cc
@@ -8,6 +8,7 @@
#include "absl/strings/string_view.h"
#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/core/quic_default_connection_helper.h"
#include "quiche/quic/core/quic_default_packet_writer.h"
#include "quiche/quic/core/quic_dispatcher.h"
#include "quiche/quic/core/quic_epoll_alarm_factory.h"
@@ -137,17 +138,11 @@
explicit QboneTestServer(std::unique_ptr<ProofSource> proof_source)
: QuicServer(std::move(proof_source), &response_cache_) {}
QuicDispatcher* CreateQuicDispatcher() override {
- QuicEpollAlarmFactory alarm_factory(epoll_server());
return new QuicQboneDispatcher(
&config(), &crypto_config(), version_manager(),
- std::unique_ptr<QuicEpollConnectionHelper>(
- new QuicEpollConnectionHelper(epoll_server(),
- QuicAllocator::BUFFER_POOL)),
- std::unique_ptr<QuicCryptoServerStreamBase::Helper>(
- new QboneCryptoServerStreamHelper()),
- std::unique_ptr<QuicEpollAlarmFactory>(
- new QuicEpollAlarmFactory(epoll_server())),
- &writer_);
+ std::make_unique<QuicDefaultConnectionHelper>(),
+ std::make_unique<QboneCryptoServerStreamHelper>(),
+ event_loop()->CreateAlarmFactory(), &writer_);
}
std::vector<std::string> data() { return writer_.data(); }
diff --git a/quiche/quic/test_tools/quic_test_server.cc b/quiche/quic/test_tools/quic_test_server.cc
index 53068df..83a060d 100644
--- a/quiche/quic/test_tools/quic_test_server.cc
+++ b/quiche/quic/test_tools/quic_test_server.cc
@@ -8,8 +8,7 @@
#include "absl/memory/memory.h"
#include "absl/strings/string_view.h"
-#include "quiche/quic/core/quic_epoll_alarm_factory.h"
-#include "quiche/quic/core/quic_epoll_connection_helper.h"
+#include "quiche/quic/core/quic_default_connection_helper.h"
#include "quiche/quic/tools/quic_simple_crypto_server_stream_helper.h"
#include "quiche/quic/tools/quic_simple_dispatcher.h"
#include "quiche/quic/tools/quic_simple_server_session.h"
@@ -178,11 +177,10 @@
QuicDispatcher* QuicTestServer::CreateQuicDispatcher() {
return new QuicTestDispatcher(
&config(), &crypto_config(), version_manager(),
- std::make_unique<QuicEpollConnectionHelper>(epoll_server(),
- QuicAllocator::BUFFER_POOL),
+ std::make_unique<QuicDefaultConnectionHelper>(),
std::unique_ptr<QuicCryptoServerStreamBase::Helper>(
new QuicSimpleCryptoServerStreamHelper()),
- std::make_unique<QuicEpollAlarmFactory>(epoll_server()), server_backend(),
+ event_loop()->CreateAlarmFactory(), server_backend(),
expected_server_connection_id_length());
}
diff --git a/quiche/quic/test_tools/server_thread.cc b/quiche/quic/test_tools/server_thread.cc
index 1594612..c0d32ea 100644
--- a/quiche/quic/test_tools/server_thread.cc
+++ b/quiche/quic/test_tools/server_thread.cc
@@ -4,6 +4,7 @@
#include "quiche/quic/test_tools/server_thread.h"
+#include "quiche/quic/core/quic_default_clock.h"
#include "quiche/quic/core/quic_dispatcher.h"
#include "quiche/quic/test_tools/crypto_test_utils.h"
#include "quiche/quic/test_tools/quic_dispatcher_peer.h"
@@ -16,7 +17,7 @@
const QuicSocketAddress& address)
: QuicThread("server_thread"),
server_(std::move(server)),
- clock_(server_->epoll_server()),
+ clock_(QuicDefaultClock::Get()),
address_(address),
port_(0),
initialized_(false) {}
@@ -73,8 +74,8 @@
bool ServerThread::WaitUntil(std::function<bool()> termination_predicate,
QuicTime::Delta timeout) {
- const QuicTime deadline = clock_.Now() + timeout;
- while (clock_.Now() < deadline) {
+ const QuicTime deadline = clock_->Now() + timeout;
+ while (clock_->Now() < deadline) {
QuicNotification done_checking;
bool should_terminate = false;
Schedule([&] {
diff --git a/quiche/quic/test_tools/server_thread.h b/quiche/quic/test_tools/server_thread.h
index fc53467..c29d633 100644
--- a/quiche/quic/test_tools/server_thread.h
+++ b/quiche/quic/test_tools/server_thread.h
@@ -8,7 +8,6 @@
#include <memory>
#include "quiche/quic/core/quic_config.h"
-#include "quiche/quic/core/quic_epoll_clock.h"
#include "quiche/quic/platform/api/quic_mutex.h"
#include "quiche/quic/platform/api/quic_socket_address.h"
#include "quiche/quic/platform/api/quic_thread.h"
@@ -79,7 +78,7 @@
QuicNotification quit_; // Notified when the server should quit.
std::unique_ptr<QuicServer> server_;
- QuicEpollClock clock_;
+ QuicClock* clock_;
QuicSocketAddress address_;
mutable QuicMutex port_lock_;
int port_ QUIC_GUARDED_BY(port_lock_);
diff --git a/quiche/quic/tools/quic_server.cc b/quiche/quic/tools/quic_server.cc
index c5ab6ea..53985e7 100644
--- a/quiche/quic/tools/quic_server.cc
+++ b/quiche/quic/tools/quic_server.cc
@@ -16,14 +16,15 @@
#include "quiche/quic/core/crypto/crypto_handshake.h"
#include "quiche/quic/core/crypto/quic_random.h"
+#include "quiche/quic/core/io/quic_default_event_loop.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/quic_clock.h"
#include "quiche/quic/core/quic_crypto_stream.h"
#include "quiche/quic/core/quic_data_reader.h"
+#include "quiche/quic/core/quic_default_clock.h"
+#include "quiche/quic/core/quic_default_connection_helper.h"
#include "quiche/quic/core/quic_default_packet_writer.h"
#include "quiche/quic/core/quic_dispatcher.h"
-#include "quiche/quic/core/quic_epoll_alarm_factory.h"
-#include "quiche/quic/core/quic_epoll_clock.h"
-#include "quiche/quic/core/quic_epoll_connection_helper.h"
#include "quiche/quic/core/quic_packet_reader.h"
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/platform/api/quic_flags.h"
@@ -36,7 +37,6 @@
namespace {
-const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
const char kSourceAddressTokenSecret[] = "secret";
} // namespace
@@ -95,17 +95,19 @@
kInitialSessionFlowControlWindow);
}
- epoll_server_.set_timeout_in_us(50 * 1000);
-
- QuicEpollClock clock(&epoll_server_);
-
std::unique_ptr<CryptoHandshakeMessage> scfg(crypto_config_.AddDefaultConfig(
- QuicRandom::GetInstance(), &clock, crypto_config_options_));
+ QuicRandom::GetInstance(), QuicDefaultClock::Get(),
+ crypto_config_options_));
}
-QuicServer::~QuicServer() = default;
+QuicServer::~QuicServer() {
+ close(fd_);
+ fd_ = -1;
+}
bool QuicServer::CreateUDPSocketAndListen(const QuicSocketAddress& address) {
+ event_loop_ = CreateEventLoop();
+
QuicUdpSocketApi socket_api;
fd_ = socket_api.Create(address.host().AddressFamilyToInt(),
/*receive_buffer_size =*/kDefaultSocketReceiveBuffer,
@@ -135,7 +137,11 @@
port_ = address.port();
}
- epoll_server_.RegisterFD(fd_, this, kEpollFlags);
+ bool register_result = event_loop_->RegisterSocket(
+ fd_, kSocketEventReadable | kSocketEventWritable, this);
+ if (!register_result) {
+ return false;
+ }
dispatcher_.reset(CreateQuicDispatcher());
dispatcher_->InitializeWithWriter(CreateWriter(fd_));
@@ -147,16 +153,17 @@
}
QuicDispatcher* QuicServer::CreateQuicDispatcher() {
- QuicEpollAlarmFactory alarm_factory(&epoll_server_);
return new QuicSimpleDispatcher(
&config_, &crypto_config_, &version_manager_,
- std::unique_ptr<QuicEpollConnectionHelper>(new QuicEpollConnectionHelper(
- &epoll_server_, QuicAllocator::BUFFER_POOL)),
+ std::make_unique<QuicDefaultConnectionHelper>(),
std::unique_ptr<QuicCryptoServerStreamBase::Helper>(
new QuicSimpleCryptoServerStreamHelper()),
- std::unique_ptr<QuicEpollAlarmFactory>(
- new QuicEpollAlarmFactory(&epoll_server_)),
- quic_simple_server_backend_, expected_server_connection_id_length_);
+ event_loop_->CreateAlarmFactory(), quic_simple_server_backend_,
+ expected_server_connection_id_length_);
+}
+
+std::unique_ptr<QuicEventLoop> QuicServer::CreateEventLoop() {
+ return GetDefaultEventLoop()->Create(QuicDefaultClock::Get());
}
void QuicServer::HandleEventsForever() {
@@ -166,7 +173,7 @@
}
void QuicServer::WaitForEvents() {
- epoll_server_.WaitForEventsAndExecuteCallbacks();
+ event_loop_->RunEventLoopOnce(QuicTime::Delta::FromMilliseconds(50));
}
void QuicServer::Shutdown() {
@@ -176,17 +183,15 @@
dispatcher_->Shutdown();
}
- epoll_server_.Shutdown();
-
- close(fd_);
- fd_ = -1;
+ dispatcher_.reset();
+ event_loop_.reset();
}
-void QuicServer::OnEvent(int fd, QuicEpollEvent* event) {
+void QuicServer::OnSocketEvent(QuicEventLoop* /*event_loop*/,
+ QuicUdpSocketFd fd, QuicSocketEventMask events) {
QUICHE_DCHECK_EQ(fd, fd_);
- event->out_ready_mask = 0;
- if (event->in_events & EPOLLIN) {
+ if (events & kSocketEventReadable) {
QUIC_DVLOG(1) << "EPOLLIN";
dispatcher_->ProcessBufferedChlos(kNumSessionsToCreatePerSocketEvent);
@@ -194,19 +199,27 @@
bool more_to_read = true;
while (more_to_read) {
more_to_read = packet_reader_->ReadAndDispatchPackets(
- fd_, port_, QuicEpollClock(&epoll_server_), dispatcher_.get(),
+ fd_, port_, *QuicDefaultClock::Get(), dispatcher_.get(),
overflow_supported_ ? &packets_dropped_ : nullptr);
}
if (dispatcher_->HasChlosBuffered()) {
// Register EPOLLIN event to consume buffered CHLO(s).
- event->out_ready_mask |= EPOLLIN;
+ bool success =
+ event_loop_->ArtificiallyNotifyEvent(fd_, kSocketEventReadable);
+ QUICHE_DCHECK(success);
+ }
+ if (!event_loop_->SupportsEdgeTriggered()) {
+ bool success = event_loop_->RearmSocket(fd_, kSocketEventReadable);
+ QUICHE_DCHECK(success);
}
}
- if (event->in_events & EPOLLOUT) {
+ if (events & kSocketEventWritable) {
dispatcher_->OnCanWrite();
- if (dispatcher_->HasPendingWrites()) {
- event->out_ready_mask |= EPOLLOUT;
+ if (!event_loop_->SupportsEdgeTriggered() &&
+ dispatcher_->HasPendingWrites()) {
+ bool success = event_loop_->RearmSocket(fd_, kSocketEventWritable);
+ QUICHE_DCHECK(success);
}
}
}
diff --git a/quiche/quic/tools/quic_server.h b/quiche/quic/tools/quic_server.h
index 5c65fe0..61531fb 100644
--- a/quiche/quic/tools/quic_server.h
+++ b/quiche/quic/tools/quic_server.h
@@ -15,8 +15,8 @@
#include "absl/strings/string_view.h"
#include "quiche/quic/core/crypto/quic_crypto_server_config.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
#include "quiche/quic/core/quic_config.h"
-#include "quiche/quic/core/quic_epoll_connection_helper.h"
#include "quiche/quic/core/quic_framer.h"
#include "quiche/quic/core/quic_packet_writer.h"
#include "quiche/quic/core/quic_udp_socket.h"
@@ -35,8 +35,7 @@
class QuicDispatcher;
class QuicPacketReader;
-class QuicServer : public QuicSpdyServerBase,
- public QuicEpollCallbackInterface {
+class QuicServer : public QuicSpdyServerBase, public QuicSocketEventListener {
public:
QuicServer(std::unique_ptr<ProofSource> proof_source,
QuicSimpleServerBackend* quic_simple_server_backend);
@@ -54,8 +53,6 @@
~QuicServer() override;
- std::string Name() const override { return "QuicServer"; }
-
// Start listening on the specified address.
bool CreateUDPSocketAndListen(const QuicSocketAddress& address) override;
// Handles all events. Does not return.
@@ -64,17 +61,12 @@
// Wait up to 50ms, and handle any events which occur.
void WaitForEvents();
- // Server deletion is imminent. Start cleaning up the epoll server.
+ // Server deletion is imminent. Start cleaning up any pending sessions.
virtual void Shutdown();
- // From EpollCallbackInterface
- void OnRegistration(QuicEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int /*fd*/, QuicEpollEvent* /*event*/) override;
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
-
- void OnShutdown(QuicEpollServer* /*eps*/, int /*fd*/) override {}
+ // QuicSocketEventListener implementation.
+ void OnSocketEvent(QuicEventLoop* event_loop, QuicUdpSocketFd fd,
+ QuicSocketEventMask events) override;
void SetChloMultiplier(size_t multiplier) {
crypto_config_.set_chlo_multiplier(multiplier);
@@ -90,13 +82,15 @@
int port() { return port_; }
- QuicEpollServer* epoll_server() { return &epoll_server_; }
+ QuicEventLoop* event_loop() { return event_loop_.get(); }
protected:
virtual QuicPacketWriter* CreateWriter(int fd);
virtual QuicDispatcher* CreateQuicDispatcher();
+ virtual std::unique_ptr<QuicEventLoop> CreateEventLoop();
+
const QuicConfig& config() const { return config_; }
const QuicCryptoServerConfig& crypto_config() const { return crypto_config_; }
@@ -120,10 +114,10 @@
// Initialize the internal state of the server.
void Initialize();
+ // Schedules alarms and notifies the server of the I/O events.
+ std::unique_ptr<QuicEventLoop> event_loop_;
// Accepts data from the framer and demuxes clients to sessions.
std::unique_ptr<QuicDispatcher> dispatcher_;
- // Frames incoming packets and hands them to the dispatcher.
- QuicEpollServer epoll_server_;
// The port the server is listening on.
int port_;
diff --git a/quiche/quic/tools/quic_server_test.cc b/quiche/quic/tools/quic_server_test.cc
index b0094be..d193fd3 100644
--- a/quiche/quic/tools/quic_server_test.cc
+++ b/quiche/quic/tools/quic_server_test.cc
@@ -4,10 +4,15 @@
#include "quiche/quic/tools/quic_server.h"
+#include <memory>
+
#include "absl/base/macros.h"
#include "quiche/quic/core/crypto/quic_random.h"
-#include "quiche/quic/core/quic_epoll_alarm_factory.h"
-#include "quiche/quic/core/quic_epoll_connection_helper.h"
+#include "quiche/quic/core/io/quic_default_event_loop.h"
+#include "quiche/quic/core/io/quic_event_loop.h"
+#include "quiche/quic/core/quic_default_clock.h"
+#include "quiche/quic/core/quic_default_connection_helper.h"
+#include "quiche/quic/core/quic_default_packet_writer.h"
#include "quiche/quic/core/quic_utils.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"
@@ -62,14 +67,10 @@
QuicDispatcher* CreateQuicDispatcher() override {
mock_dispatcher_ = new MockQuicSimpleDispatcher(
&config(), &crypto_config(), version_manager(),
- std::unique_ptr<QuicEpollConnectionHelper>(
- new QuicEpollConnectionHelper(epoll_server(),
- QuicAllocator::BUFFER_POOL)),
+ std::make_unique<QuicDefaultConnectionHelper>(),
std::unique_ptr<QuicCryptoServerStreamBase::Helper>(
new QuicSimpleCryptoServerStreamHelper()),
- std::unique_ptr<QuicEpollAlarmFactory>(
- new QuicEpollAlarmFactory(epoll_server())),
- &quic_simple_server_backend_);
+ event_loop()->CreateAlarmFactory(), &quic_simple_server_backend_);
return mock_dispatcher_;
}
@@ -147,14 +148,11 @@
crypto_test_utils::ProofSourceForTesting(),
KeyExchangeSource::Default()),
version_manager_(AllSupportedVersions()),
+ event_loop_(GetDefaultEventLoop()->Create(QuicDefaultClock::Get())),
dispatcher_(&config_, &crypto_config_, &version_manager_,
- std::unique_ptr<QuicEpollConnectionHelper>(
- new QuicEpollConnectionHelper(
- &eps_, QuicAllocator::BUFFER_POOL)),
- std::unique_ptr<QuicCryptoServerStreamBase::Helper>(
- new QuicSimpleCryptoServerStreamHelper()),
- std::unique_ptr<QuicEpollAlarmFactory>(
- new QuicEpollAlarmFactory(&eps_)),
+ std::make_unique<QuicDefaultConnectionHelper>(),
+ std::make_unique<QuicSimpleCryptoServerStreamHelper>(),
+ event_loop_->CreateAlarmFactory(),
&quic_simple_server_backend_) {
dispatcher_.InitializeWithWriter(new QuicDefaultPacketWriter(1234));
}
@@ -168,7 +166,7 @@
QuicConfig config_;
QuicCryptoServerConfig crypto_config_;
QuicVersionManager version_manager_;
- QuicEpollServer eps_;
+ std::unique_ptr<QuicEventLoop> event_loop_;
QuicMemoryCacheBackend quic_simple_server_backend_;
MockQuicDispatcher dispatcher_;
};
