Unexport //third_party/epoll_server
Nothing in QUICHE depends on it anymore.
PiperOrigin-RevId: 474535563
diff --git a/build/source_list.bzl b/build/source_list.bzl
index fa32a50..808114a 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -948,10 +948,6 @@
"common/platform/api/quiche_event_loop.h",
"common/platform/api/quiche_stream_buffer_allocator.h",
"common/platform/api/quiche_udp_socket_platform_api.h",
- "epoll_server/platform/api/epoll_bug.h",
- "epoll_server/platform/api/epoll_logging.h",
- "epoll_server/platform/api/epoll_thread.h",
- "epoll_server/simple_epoll_server.h",
"quic/core/batch_writer/quic_batch_writer_base.h",
"quic/core/batch_writer/quic_batch_writer_buffer.h",
"quic/core/batch_writer/quic_batch_writer_test.h",
@@ -984,7 +980,6 @@
"quic/tools/quic_server.h",
]
epoll_tool_support_srcs = [
- "epoll_server/simple_epoll_server.cc",
"quic/core/batch_writer/quic_batch_writer_base.cc",
"quic/core/batch_writer/quic_batch_writer_buffer.cc",
"quic/core/batch_writer/quic_gso_batch_writer.cc",
@@ -1012,10 +1007,6 @@
"quic/tools/quic_server.cc",
]
epoll_test_support_hdrs = [
- "epoll_server/fake_simple_epoll_server.h",
- "epoll_server/platform/api/epoll_address_test_utils.h",
- "epoll_server/platform/api/epoll_expect_bug.h",
- "epoll_server/platform/api/epoll_test.h",
"quic/bindings/quic_libevent.h",
"quic/test_tools/quic_mock_syscall_wrapper.h",
"quic/test_tools/quic_server_peer.h",
@@ -1024,7 +1015,6 @@
"quic/test_tools/server_thread.h",
]
epoll_test_support_srcs = [
- "epoll_server/fake_simple_epoll_server.cc",
"quic/bindings/quic_libevent.cc",
"quic/test_tools/quic_mock_syscall_wrapper.cc",
"quic/test_tools/quic_server_peer.cc",
@@ -1296,7 +1286,6 @@
]
epoll_tests_srcs = [
- "epoll_server/simple_epoll_server_test.cc",
"quic/core/batch_writer/quic_batch_writer_buffer_test.cc",
"quic/core/batch_writer/quic_batch_writer_test.cc",
"quic/core/batch_writer/quic_gso_batch_writer_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index d36d591..a03ebc5 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -948,10 +948,6 @@
"src/quiche/common/platform/api/quiche_event_loop.h",
"src/quiche/common/platform/api/quiche_stream_buffer_allocator.h",
"src/quiche/common/platform/api/quiche_udp_socket_platform_api.h",
- "src/quiche/epoll_server/platform/api/epoll_bug.h",
- "src/quiche/epoll_server/platform/api/epoll_logging.h",
- "src/quiche/epoll_server/platform/api/epoll_thread.h",
- "src/quiche/epoll_server/simple_epoll_server.h",
"src/quiche/quic/core/batch_writer/quic_batch_writer_base.h",
"src/quiche/quic/core/batch_writer/quic_batch_writer_buffer.h",
"src/quiche/quic/core/batch_writer/quic_batch_writer_test.h",
@@ -984,7 +980,6 @@
"src/quiche/quic/tools/quic_server.h",
]
epoll_tool_support_srcs = [
- "src/quiche/epoll_server/simple_epoll_server.cc",
"src/quiche/quic/core/batch_writer/quic_batch_writer_base.cc",
"src/quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc",
"src/quiche/quic/core/batch_writer/quic_gso_batch_writer.cc",
@@ -1012,10 +1007,6 @@
"src/quiche/quic/tools/quic_server.cc",
]
epoll_test_support_hdrs = [
- "src/quiche/epoll_server/fake_simple_epoll_server.h",
- "src/quiche/epoll_server/platform/api/epoll_address_test_utils.h",
- "src/quiche/epoll_server/platform/api/epoll_expect_bug.h",
- "src/quiche/epoll_server/platform/api/epoll_test.h",
"src/quiche/quic/bindings/quic_libevent.h",
"src/quiche/quic/test_tools/quic_mock_syscall_wrapper.h",
"src/quiche/quic/test_tools/quic_server_peer.h",
@@ -1024,7 +1015,6 @@
"src/quiche/quic/test_tools/server_thread.h",
]
epoll_test_support_srcs = [
- "src/quiche/epoll_server/fake_simple_epoll_server.cc",
"src/quiche/quic/bindings/quic_libevent.cc",
"src/quiche/quic/test_tools/quic_mock_syscall_wrapper.cc",
"src/quiche/quic/test_tools/quic_server_peer.cc",
@@ -1296,7 +1286,6 @@
]
epoll_tests_srcs = [
- "src/quiche/epoll_server/simple_epoll_server_test.cc",
"src/quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc",
"src/quiche/quic/core/batch_writer/quic_batch_writer_test.cc",
"src/quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 753c2fd..cf5abb2 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -947,10 +947,6 @@
"quiche/common/platform/api/quiche_event_loop.h",
"quiche/common/platform/api/quiche_stream_buffer_allocator.h",
"quiche/common/platform/api/quiche_udp_socket_platform_api.h",
- "quiche/epoll_server/platform/api/epoll_bug.h",
- "quiche/epoll_server/platform/api/epoll_logging.h",
- "quiche/epoll_server/platform/api/epoll_thread.h",
- "quiche/epoll_server/simple_epoll_server.h",
"quiche/quic/core/batch_writer/quic_batch_writer_base.h",
"quiche/quic/core/batch_writer/quic_batch_writer_buffer.h",
"quiche/quic/core/batch_writer/quic_batch_writer_test.h",
@@ -983,7 +979,6 @@
"quiche/quic/tools/quic_server.h"
],
"epoll_tool_support_srcs": [
- "quiche/epoll_server/simple_epoll_server.cc",
"quiche/quic/core/batch_writer/quic_batch_writer_base.cc",
"quiche/quic/core/batch_writer/quic_batch_writer_buffer.cc",
"quiche/quic/core/batch_writer/quic_gso_batch_writer.cc",
@@ -1011,10 +1006,6 @@
"quiche/quic/tools/quic_server.cc"
],
"epoll_test_support_hdrs": [
- "quiche/epoll_server/fake_simple_epoll_server.h",
- "quiche/epoll_server/platform/api/epoll_address_test_utils.h",
- "quiche/epoll_server/platform/api/epoll_expect_bug.h",
- "quiche/epoll_server/platform/api/epoll_test.h",
"quiche/quic/bindings/quic_libevent.h",
"quiche/quic/test_tools/quic_mock_syscall_wrapper.h",
"quiche/quic/test_tools/quic_server_peer.h",
@@ -1023,7 +1014,6 @@
"quiche/quic/test_tools/server_thread.h"
],
"epoll_test_support_srcs": [
- "quiche/epoll_server/fake_simple_epoll_server.cc",
"quiche/quic/bindings/quic_libevent.cc",
"quiche/quic/test_tools/quic_mock_syscall_wrapper.cc",
"quiche/quic/test_tools/quic_server_peer.cc",
@@ -1295,7 +1285,6 @@
],
"epoll_tests_srcs": [
- "quiche/epoll_server/simple_epoll_server_test.cc",
"quiche/quic/core/batch_writer/quic_batch_writer_buffer_test.cc",
"quiche/quic/core/batch_writer/quic_batch_writer_test.cc",
"quiche/quic/core/batch_writer/quic_gso_batch_writer_test.cc",
diff --git a/quiche/epoll_server/fake_simple_epoll_server.cc b/quiche/epoll_server/fake_simple_epoll_server.cc
deleted file mode 100644
index f21ae1c..0000000
--- a/quiche/epoll_server/fake_simple_epoll_server.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quiche/epoll_server/fake_simple_epoll_server.h"
-
-namespace epoll_server {
-namespace test {
-
-FakeTimeSimpleEpollServer::FakeTimeSimpleEpollServer() : now_in_usec_(0) {}
-
-FakeTimeSimpleEpollServer::~FakeTimeSimpleEpollServer() = default;
-
-int64_t FakeTimeSimpleEpollServer::NowInUsec() const { return now_in_usec_; }
-
-FakeSimpleEpollServer::FakeSimpleEpollServer() : until_in_usec_(-1) {}
-
-FakeSimpleEpollServer::~FakeSimpleEpollServer() = default;
-
-int FakeSimpleEpollServer::epoll_wait_impl(int /*epfd*/,
- struct epoll_event* events,
- int max_events, int timeout_in_ms) {
- int num_events = 0;
- while (!event_queue_.empty() && num_events < max_events &&
- event_queue_.begin()->first <= NowInUsec() &&
- ((until_in_usec_ == -1) ||
- (event_queue_.begin()->first < until_in_usec_))) {
- int64_t event_time_in_usec = event_queue_.begin()->first;
- events[num_events] = event_queue_.begin()->second;
- if (event_time_in_usec > NowInUsec()) {
- set_now_in_usec(event_time_in_usec);
- }
- event_queue_.erase(event_queue_.begin());
- ++num_events;
- }
- if (num_events == 0) { // then we'd have waited 'till the timeout.
- if (until_in_usec_ < 0) { // then we don't care what the final time is.
- if (timeout_in_ms > 0) {
- AdvanceBy(timeout_in_ms * 1000);
- }
- } else { // except we assume that we don't wait for the timeout
- // period if until_in_usec_ is a positive number.
- set_now_in_usec(until_in_usec_);
- // And reset until_in_usec_ to signal no waiting (as
- // the AdvanceByExactly* stuff is meant to be one-shot,
- // as are all similar net::EpollServer functions)
- until_in_usec_ = -1;
- }
- }
- if (until_in_usec_ >= 0) {
- CHECK(until_in_usec_ >= NowInUsec());
- }
- return num_events;
-}
-
-} // namespace test
-} // namespace epoll_server
diff --git a/quiche/epoll_server/fake_simple_epoll_server.h b/quiche/epoll_server/fake_simple_epoll_server.h
deleted file mode 100644
index 62c9dd1..0000000
--- a/quiche/epoll_server/fake_simple_epoll_server.h
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_FAKE_SIMPLE_EPOLL_SERVER_H_
-#define QUICHE_EPOLL_SERVER_FAKE_SIMPLE_EPOLL_SERVER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-
-#include "quiche/epoll_server/simple_epoll_server.h"
-
-namespace epoll_server {
-namespace test {
-
-// Unlike the full FakeEpollServer, this only lies about the time but lets
-// fd events operate normally. Usefully when interacting with real backends
-// but wanting to skip forward in time to trigger timeouts.
-class FakeTimeSimpleEpollServer : public SimpleEpollServer {
- public:
- FakeTimeSimpleEpollServer();
- FakeTimeSimpleEpollServer(const FakeTimeSimpleEpollServer&) = delete;
- FakeTimeSimpleEpollServer operator=(const FakeTimeSimpleEpollServer&) =
- delete;
-
- ~FakeTimeSimpleEpollServer() override;
-
- // Replaces the net::EpollServer NowInUsec.
- int64_t NowInUsec() const override;
-
- void set_now_in_usec(int64_t nius) { now_in_usec_ = nius; }
-
- // Advances the virtual 'now' by advancement_usec.
- void AdvanceBy(int64_t advancement_usec) {
- set_now_in_usec(NowInUsec() + advancement_usec);
- }
-
- // Advances the virtual 'now' by advancement_usec, and
- // calls WaitForEventAndExecteCallbacks.
- // Note that the WaitForEventsAndExecuteCallbacks invocation
- // may cause NowInUs to advance beyond what was specified here.
- // If that is not desired, use the AdvanceByExactly calls.
- void AdvanceByAndWaitForEventsAndExecuteCallbacks(int64_t advancement_usec) {
- AdvanceBy(advancement_usec);
- WaitForEventsAndExecuteCallbacks();
- }
-
- private:
- int64_t now_in_usec_;
-};
-
-class FakeSimpleEpollServer : public FakeTimeSimpleEpollServer {
- public: // type definitions
- using EventQueue = std::multimap<int64_t, struct epoll_event>;
-
- FakeSimpleEpollServer();
- FakeSimpleEpollServer(const FakeSimpleEpollServer&) = delete;
- FakeSimpleEpollServer operator=(const FakeSimpleEpollServer&) = delete;
-
- ~FakeSimpleEpollServer() override;
-
- // time_in_usec is the time at which the event specified
- // by 'ee' will be delivered. Note that it -is- possible
- // to add an event for a time which has already been passed..
- // .. upon the next time that the callbacks are invoked,
- // all events which are in the 'past' will be delivered.
- void AddEvent(int64_t time_in_usec, const struct epoll_event& ee) {
- event_queue_.insert(std::make_pair(time_in_usec, ee));
- }
-
- // Advances the virtual 'now' by advancement_usec,
- // and ensure that the next invocation of
- // WaitForEventsAndExecuteCallbacks goes no farther than
- // advancement_usec from the current time.
- void AdvanceByExactly(int64_t advancement_usec) {
- until_in_usec_ = NowInUsec() + advancement_usec;
- set_now_in_usec(NowInUsec() + advancement_usec);
- }
-
- // As above, except calls WaitForEventsAndExecuteCallbacks.
- void AdvanceByExactlyAndCallCallbacks(int64_t advancement_usec) {
- AdvanceByExactly(advancement_usec);
- WaitForEventsAndExecuteCallbacks();
- }
-
- std::unordered_set<AlarmCB*>::size_type NumberOfAlarms() const {
- return all_alarms_.size();
- }
-
- protected: // functions
- // These functions do nothing here, as we're not actually
- // using the epoll_* syscalls.
- void DelFD(int /*fd*/) const override {}
- void AddFD(int /*fd*/, int /*event_mask*/) const override {}
- void ModFD(int /*fd*/, int /*event_mask*/) const override {}
-
- // Replaces the epoll_server's epoll_wait_impl.
- int epoll_wait_impl(int epfd, struct epoll_event* events, int max_events,
- int timeout_in_ms) override;
- void SetNonblocking(int /*fd*/) override {}
-
- private: // members
- EventQueue event_queue_;
- int64_t until_in_usec_;
-};
-
-} // namespace test
-} // namespace epoll_server
-
-#endif // QUICHE_EPOLL_SERVER_FAKE_SIMPLE_EPOLL_SERVER_H_
diff --git a/quiche/epoll_server/platform/api/epoll_address_test_utils.h b/quiche/epoll_server/platform/api/epoll_address_test_utils.h
deleted file mode 100644
index 883d510..0000000
--- a/quiche/epoll_server/platform/api/epoll_address_test_utils.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_ADDRESS_TEST_UTILS_H_
-#define QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_ADDRESS_TEST_UTILS_H_
-
-#include "quiche_platform_impl/epoll_address_test_utils_impl.h"
-
-namespace epoll_server {
-
-inline int AddressFamilyUnderTest() { return AddressFamilyUnderTestImpl(); }
-
-} // namespace epoll_server
-
-#endif // QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_ADDRESS_TEST_UTILS_H_
diff --git a/quiche/epoll_server/platform/api/epoll_bug.h b/quiche/epoll_server/platform/api/epoll_bug.h
deleted file mode 100644
index eeb707a..0000000
--- a/quiche/epoll_server/platform/api/epoll_bug.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_BUG_H_
-#define QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_BUG_H_
-
-#include "quiche_platform_impl/epoll_bug_impl.h"
-
-#define EPOLL_BUG EPOLL_BUG_IMPL
-
-#endif // QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_BUG_H_
diff --git a/quiche/epoll_server/platform/api/epoll_expect_bug.h b/quiche/epoll_server/platform/api/epoll_expect_bug.h
deleted file mode 100644
index 36ebd97..0000000
--- a/quiche/epoll_server/platform/api/epoll_expect_bug.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_EXPECT_BUG_H_
-#define QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_EXPECT_BUG_H_
-
-#include "quiche_platform_impl/epoll_expect_bug_impl.h"
-
-#define EXPECT_EPOLL_BUG EXPECT_EPOLL_BUG_IMPL
-
-#endif // QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_EXPECT_BUG_H_
diff --git a/quiche/epoll_server/platform/api/epoll_logging.h b/quiche/epoll_server/platform/api/epoll_logging.h
deleted file mode 100644
index 2d5a0f4..0000000
--- a/quiche/epoll_server/platform/api/epoll_logging.h
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_LOGGING_H_
-#define QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_LOGGING_H_
-
-#include "quiche_platform_impl/epoll_logging_impl.h"
-
-namespace epoll_server {
-
-#define EPOLL_LOG(severity) EPOLL_LOG_IMPL(severity)
-#define EPOLL_VLOG(verbosity) EPOLL_VLOG_IMPL(verbosity)
-#define EPOLL_DVLOG(verbosity) EPOLL_DVLOG_IMPL(verbosity)
-#define EPOLL_PLOG(severity) EPOLL_PLOG_IMPL(severity)
-
-} // namespace epoll_server
-
-#endif // QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_LOGGING_H_
diff --git a/quiche/epoll_server/platform/api/epoll_test.h b/quiche/epoll_server/platform/api/epoll_test.h
deleted file mode 100644
index c7f0eea..0000000
--- a/quiche/epoll_server/platform/api/epoll_test.h
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_TEST_H_
-#define QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_TEST_H_
-
-#include "quiche_platform_impl/epoll_test_impl.h"
-#define EpollTest EpollTestImpl
-
-#endif // QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_TEST_H_
diff --git a/quiche/epoll_server/platform/api/epoll_thread.h b/quiche/epoll_server/platform/api/epoll_thread.h
deleted file mode 100644
index 5b159cb..0000000
--- a/quiche/epoll_server/platform/api/epoll_thread.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_THREAD_H_
-#define QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_THREAD_H_
-
-#include <string>
-
-#include "quiche_platform_impl/epoll_thread_impl.h"
-
-namespace epoll_server {
-
-// A class representing a thread of execution in QUIC.
-class EpollThread : public EpollThreadImpl {
- public:
- EpollThread(const std::string& string) : EpollThreadImpl(string) {}
- EpollThread(const EpollThread&) = delete;
- EpollThread& operator=(const EpollThread&) = delete;
-
- // Impl defines a virtual void Run() method which subclasses
- // must implement.
-};
-
-} // namespace epoll_server
-
-#endif // QUICHE_EPOLL_SERVER_PLATFORM_API_EPOLL_THREAD_H_
diff --git a/quiche/epoll_server/simple_epoll_server.cc b/quiche/epoll_server/simple_epoll_server.cc
deleted file mode 100644
index eb9d6c4..0000000
--- a/quiche/epoll_server/simple_epoll_server.cc
+++ /dev/null
@@ -1,815 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quiche/epoll_server/simple_epoll_server.h"
-
-#include <errno.h> // for errno
-#include <stdlib.h> // for abort
-#include <string.h> // for strerror_r
-#include <unistd.h> // For read, pipe, close and write.
-
-#include <algorithm>
-#include <utility>
-
-#include "absl/time/clock.h"
-#include "quiche/epoll_server/platform/api/epoll_bug.h"
-
-// Design notes: An efficient implementation of ready list has the following
-// desirable properties:
-//
-// A. O(1) insertion into/removal from the list in any location.
-// B. Once the callback is found by hash lookup using the fd, the lookup of
-// corresponding entry in the list is O(1).
-// C. Safe insertion into/removal from the list during list iteration. (The
-// ready list's purpose is to enable completely event driven I/O model.
-// Thus, all the interesting bits happen in the callback. It is critical
-// to not place any restriction on the API during list iteration.
-//
-// The current implementation achieves these goals with the following design:
-//
-// - The ready list is constructed as a doubly linked list to enable O(1)
-// insertion/removal (see man 3 queue).
-// - The forward and backward links are directly embedded inside the
-// CBAndEventMask struct. This enables O(1) lookup in the list for a given
-// callback. (Techincally, we could've used std::list of hash_set::iterator,
-// and keep a list::iterator in CBAndEventMask to achieve the same effect.
-// However, iterators have two problems: no way to portably invalidate them,
-// and no way to tell whether an iterator is singular or not. The only way to
-// overcome these issues is to keep bools in both places, but that throws off
-// memory alignment (up to 7 wasted bytes for each bool). The extra level of
-// indirection will also likely be less cache friendly. Direct manipulation
-// of link pointers makes it easier to retrieve the CBAndEventMask from the
-// list, easier to check whether an CBAndEventMask is in the list, uses less
-// memory (save 32 bytes/fd), and does not affect cache usage (we need to
-// read in the struct to use the callback anyway).)
-// - Embed the fd directly into CBAndEventMask and switch to using hash_set.
-// This removes the need to store hash_map::iterator in the list just so that
-// we can get both the fd and the callback.
-// - The ready list is "one shot": each entry is removed before OnEvent is
-// called. This removes the mutation-while-iterating problem.
-// - Use two lists to keep track of callbacks. The ready_list_ is the one used
-// for registration. Before iteration, the ready_list_ is swapped into the
-// tmp_list_. Once iteration is done, tmp_list_ will be empty, and
-// ready_list_ will have all the new ready fds.
-
-// The size we use for buffers passed to strerror_r
-static const int kErrorBufferSize = 256;
-
-namespace epoll_server {
-
-template <typename T>
-class AutoReset {
- public:
- AutoReset(T* scoped_variable, T new_value)
- : scoped_variable_(scoped_variable),
- original_value_(std::move(*scoped_variable)) {
- *scoped_variable_ = std::move(new_value);
- }
- AutoReset(const AutoReset&) = delete;
- AutoReset& operator=(const AutoReset&) = delete;
-
- ~AutoReset() { *scoped_variable_ = std::move(original_value_); }
-
- private:
- T* scoped_variable_;
- T original_value_;
-};
-
-// Clears the pipe and returns. Used for waking the epoll server up.
-class ReadPipeCallback : public EpollCallbackInterface {
- public:
- void OnEvent(int fd, EpollEvent* event) override {
- DCHECK(event->in_events == EPOLLIN);
- int data;
- int data_read = 1;
- // Read until the pipe is empty.
- while (data_read > 0) {
- data_read = read(fd, &data, sizeof(data));
- }
- }
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {}
- void OnRegistration(SimpleEpollServer*, int, int) override {}
- void OnModification(int, int) override {} // COV_NF_LINE
- void OnUnregistration(int, bool) override {} // COV_NF_LINE
- std::string Name() const override { return "ReadPipeCallback"; }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-SimpleEpollServer::SimpleEpollServer()
- : epoll_fd_(epoll_create(1024)),
- timeout_in_us_(0),
- recorded_now_in_us_(0),
- ready_list_size_(0),
- wake_cb_(new ReadPipeCallback),
- read_fd_(-1),
- write_fd_(-1),
- in_wait_for_events_and_execute_callbacks_(false),
- in_shutdown_(false),
- last_delay_in_usec_(0) {
- // ensure that the epoll_fd_ is valid.
- CHECK_NE(epoll_fd_, -1);
- LIST_INIT(&ready_list_);
- LIST_INIT(&tmp_list_);
-
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- // Unfortunately, it is impossible to test any such initialization in
- // a constructor (as virtual methods do not yet work).
- // This -could- be solved by moving initialization to an outside
- // call...
- int saved_errno = errno;
- char buf[kErrorBufferSize];
- EPOLL_LOG(FATAL) << "Error " << saved_errno << " in pipe(): "
- << strerror_r(saved_errno, buf, sizeof(buf));
- }
- read_fd_ = pipe_fds[0];
- write_fd_ = pipe_fds[1];
- RegisterFD(read_fd_, wake_cb_.get(), EPOLLIN);
-}
-
-void SimpleEpollServer::CleanupFDToCBMap() {
- auto cb_iter = cb_map_.begin();
- while (cb_iter != cb_map_.end()) {
- int fd = cb_iter->fd;
- CB* cb = cb_iter->cb;
-
- cb_iter->in_use = true;
- if (cb) {
- cb->OnShutdown(this, fd);
- }
-
- cb_map_.erase(cb_iter);
- cb_iter = cb_map_.begin();
- }
-}
-
-void SimpleEpollServer::CleanupTimeToAlarmCBMap() {
- TimeToAlarmCBMap::iterator erase_it;
-
- // Call OnShutdown() on alarms. Note that the structure of the loop
- // is similar to the structure of loop in the function HandleAlarms()
- for (auto i = alarm_map_.begin(); i != alarm_map_.end();) {
- // Note that OnShutdown() can call UnregisterAlarm() on
- // other iterators. OnShutdown() should not call UnregisterAlarm()
- // on self because by definition the iterator is not valid any more.
- i->second->OnShutdown(this);
- erase_it = i;
- ++i;
- alarm_map_.erase(erase_it);
- }
-}
-
-SimpleEpollServer::~SimpleEpollServer() {
- DCHECK_EQ(in_shutdown_, false);
- in_shutdown_ = true;
-#ifdef EPOLL_SERVER_EVENT_TRACING
- EPOLL_LOG(INFO) << "\n" << event_recorder_;
-#endif
- EPOLL_VLOG(2) << "Shutting down epoll server ";
- CleanupFDToCBMap();
-
- LIST_INIT(&ready_list_);
- LIST_INIT(&tmp_list_);
-
- CleanupTimeToAlarmCBMap();
-
- close(read_fd_);
- close(write_fd_);
- close(epoll_fd_);
-}
-
-// Whether a CBAandEventMask is on the ready list is determined by a non-NULL
-// le_prev pointer (le_next being NULL indicates end of list).
-inline void SimpleEpollServer::AddToReadyList(CBAndEventMask* cb_and_mask) {
- if (cb_and_mask->entry.le_prev == NULL) {
- LIST_INSERT_HEAD(&ready_list_, cb_and_mask, entry);
- ++ready_list_size_;
- }
-}
-
-inline void SimpleEpollServer::RemoveFromReadyList(
- const CBAndEventMask& cb_and_mask) {
- if (cb_and_mask.entry.le_prev != NULL) {
- LIST_REMOVE(&cb_and_mask, entry);
- // Clean up all the ready list states. Don't bother with the other fields
- // as they are initialized when the CBAandEventMask is added to the ready
- // list. This saves a few cycles in the inner loop.
- cb_and_mask.entry.le_prev = NULL;
- --ready_list_size_;
- if (ready_list_size_ == 0) {
- DCHECK(ready_list_.lh_first == NULL);
- DCHECK(tmp_list_.lh_first == NULL);
- }
- }
-}
-
-void SimpleEpollServer::RegisterFD(int fd, CB* cb, int event_mask) {
- CHECK(cb);
- EPOLL_VLOG(3) << "RegisterFD fd=" << fd << " event_mask=" << event_mask;
- auto fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
- if (cb_map_.end() != fd_i) {
- // do we just abort, or do we just unregister the other callback?
- // for now, lets just unregister the other callback.
-
- // unregister any callback that may already be registered for this FD.
- CB* other_cb = fd_i->cb;
- if (other_cb) {
- // Must remove from the ready list before erasing.
- RemoveFromReadyList(*fd_i);
- other_cb->OnUnregistration(fd, true);
- ModFD(fd, event_mask);
- } else {
- // already unregistered, so just recycle the node.
- AddFD(fd, event_mask);
- }
- fd_i->cb = cb;
- fd_i->event_mask = event_mask;
- fd_i->events_to_fake = 0;
- } else {
- AddFD(fd, event_mask);
- cb_map_.insert(CBAndEventMask(cb, event_mask, fd));
- }
-
- // set the FD to be non-blocking.
- SetNonblocking(fd);
-
- cb->OnRegistration(this, fd, event_mask);
-}
-
-void SimpleEpollServer::SetNonblocking(int fd) {
- int flags = fcntl(fd, F_GETFL, 0);
- if (flags == -1) {
- int saved_errno = errno;
- char buf[kErrorBufferSize];
- EPOLL_LOG(FATAL) << "Error " << saved_errno << " doing fcntl(" << fd
- << ", F_GETFL, 0): "
- << strerror_r(saved_errno, buf, sizeof(buf));
- }
- if (!(flags & O_NONBLOCK)) {
- int saved_flags = flags;
- flags = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
- if (flags == -1) {
- // bad.
- int saved_errno = errno;
- char buf[kErrorBufferSize];
- EPOLL_LOG(FATAL) << "Error " << saved_errno << " doing fcntl(" << fd
- << ", F_SETFL, " << saved_flags
- << "): " << strerror_r(saved_errno, buf, sizeof(buf));
- }
- }
-}
-
-int SimpleEpollServer::epoll_wait_impl(int epfd, struct epoll_event* events,
- int max_events, int timeout_in_ms) {
- return epoll_wait(epfd, events, max_events, timeout_in_ms);
-}
-
-void SimpleEpollServer::RegisterFDForWrite(int fd, CB* cb) {
- RegisterFD(fd, cb, EPOLLOUT);
-}
-
-void SimpleEpollServer::RegisterFDForReadWrite(int fd, CB* cb) {
- RegisterFD(fd, cb, EPOLLIN | EPOLLOUT);
-}
-
-void SimpleEpollServer::RegisterFDForRead(int fd, CB* cb) {
- RegisterFD(fd, cb, EPOLLIN);
-}
-
-void SimpleEpollServer::UnregisterFD(int fd) {
- auto fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
- if (cb_map_.end() == fd_i || fd_i->cb == NULL) {
- // Doesn't exist in server, or has gone through UnregisterFD once and still
- // inside the callchain of OnEvent.
- return;
- }
-#ifdef EPOLL_SERVER_EVENT_TRACING
- event_recorder_.RecordUnregistration(fd);
-#endif
- CB* cb = fd_i->cb;
- // Since the links are embedded within the struct, we must remove it from the
- // list before erasing it from the hash_set.
- RemoveFromReadyList(*fd_i);
- DelFD(fd);
- cb->OnUnregistration(fd, false);
- // fd_i->cb is NULL if that fd is unregistered inside the callchain of
- // OnEvent. Since the SimpleEpollServer needs a valid CBAndEventMask after
- // OnEvent returns in order to add it to the ready list, we cannot have
- // UnregisterFD erase the entry if it is in use. Thus, a NULL fd_i->cb is used
- // as a condition that tells the SimpleEpollServer that this entry is unused
- // at a later point.
- if (!fd_i->in_use) {
- cb_map_.erase(fd_i);
- } else {
- // Remove all trace of the registration, and just keep the node alive long
- // enough so the code that calls OnEvent doesn't have to worry about
- // figuring out whether the CBAndEventMask is valid or not.
- fd_i->cb = NULL;
- fd_i->event_mask = 0;
- fd_i->events_to_fake = 0;
- }
-}
-
-void SimpleEpollServer::ModifyCallback(int fd, int event_mask) {
- ModifyFD(fd, ~0, event_mask);
-}
-
-void SimpleEpollServer::StopRead(int fd) { ModifyFD(fd, EPOLLIN, 0); }
-
-void SimpleEpollServer::StartRead(int fd) { ModifyFD(fd, 0, EPOLLIN); }
-
-void SimpleEpollServer::StopWrite(int fd) { ModifyFD(fd, EPOLLOUT, 0); }
-
-void SimpleEpollServer::StartWrite(int fd) { ModifyFD(fd, 0, EPOLLOUT); }
-
-void SimpleEpollServer::HandleEvent(int fd, int event_mask) {
-#ifdef EPOLL_SERVER_EVENT_TRACING
- event_recorder_.RecordEpollEvent(fd, event_mask);
-#endif
- auto fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
- if (fd_i == cb_map_.end() || fd_i->cb == NULL) {
- // Ignore the event.
- // This could occur if epoll() returns a set of events, and
- // while processing event A (earlier) we removed the callback
- // for event B (and are now processing event B).
- return;
- }
- fd_i->events_asserted = event_mask;
- CBAndEventMask* cb_and_mask = const_cast<CBAndEventMask*>(&*fd_i);
- AddToReadyList(cb_and_mask);
-}
-
-void SimpleEpollServer::WaitForEventsAndExecuteCallbacks() {
- if (in_wait_for_events_and_execute_callbacks_) {
- EPOLL_LOG(DFATAL) << "Attempting to call WaitForEventsAndExecuteCallbacks"
- " when an ancestor to the current function is already"
- " WaitForEventsAndExecuteCallbacks!";
- // The line below is actually tested, but in coverage mode,
- // we never see it.
- return; // COV_NF_LINE
- }
- AutoReset<bool> recursion_guard(&in_wait_for_events_and_execute_callbacks_,
- true);
- if (alarm_map_.empty()) {
- // no alarms, this is business as usual.
- WaitForEventsAndCallHandleEvents(timeout_in_us_, events_, events_size_);
- recorded_now_in_us_ = 0;
- return;
- }
-
- // store the 'now'. If we recomputed 'now' every iteration
- // down below, then we might never exit that loop-- any
- // long-running alarms might install other long-running
- // alarms, etc. By storing it here now, we ensure that
- // a more reasonable amount of work is done here.
- int64_t now_in_us = NowInUsec();
-
- // Get the first timeout from the alarm_map where it is
- // stored in absolute time.
- int64_t next_alarm_time_in_us = alarm_map_.begin()->first;
- EPOLL_VLOG(4) << "next_alarm_time = " << next_alarm_time_in_us
- << " now = " << now_in_us
- << " timeout_in_us = " << timeout_in_us_;
-
- int64_t wait_time_in_us;
- int64_t alarm_timeout_in_us = next_alarm_time_in_us - now_in_us;
-
- // If the next alarm is sooner than the default timeout, or if there is no
- // timeout (timeout_in_us_ == -1), wake up when the alarm should fire.
- // Otherwise use the default timeout.
- if (alarm_timeout_in_us < timeout_in_us_ || timeout_in_us_ < 0) {
- wait_time_in_us = std::max(alarm_timeout_in_us, static_cast<int64_t>(0));
- } else {
- wait_time_in_us = timeout_in_us_;
- }
-
- EPOLL_VLOG(4) << "wait_time_in_us = " << wait_time_in_us;
-
- // wait for events.
-
- WaitForEventsAndCallHandleEvents(wait_time_in_us, events_, events_size_);
- CallAndReregisterAlarmEvents();
- recorded_now_in_us_ = 0;
-}
-
-void SimpleEpollServer::SetFDReady(int fd, int events_to_fake) {
- auto fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
- if (cb_map_.end() != fd_i && fd_i->cb != NULL) {
- // This const_cast is necessary for LIST_HEAD_INSERT to work. Declaring
- // entry mutable is insufficient because LIST_HEAD_INSERT assigns the
- // forward pointer of the list head to the current cb_and_mask, and the
- // compiler complains that it can't assign a const T* to a T*.
- CBAndEventMask* cb_and_mask = const_cast<CBAndEventMask*>(&*fd_i);
- // Note that there is no clearly correct behavior here when
- // cb_and_mask->events_to_fake != 0 and this function is called.
- // Of the two operations:
- // cb_and_mask->events_to_fake = events_to_fake
- // cb_and_mask->events_to_fake |= events_to_fake
- // the first was picked because it discourages users from calling
- // SetFDReady repeatedly to build up the correct event set as it is more
- // efficient to call SetFDReady once with the correct, final mask.
- cb_and_mask->events_to_fake = events_to_fake;
- AddToReadyList(cb_and_mask);
- }
-}
-
-void SimpleEpollServer::SetFDNotReady(int fd) {
- auto fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
- if (cb_map_.end() != fd_i) {
- RemoveFromReadyList(*fd_i);
- }
-}
-
-bool SimpleEpollServer::IsFDReady(int fd) const {
- auto fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
- return (cb_map_.end() != fd_i && fd_i->cb != NULL &&
- fd_i->entry.le_prev != NULL);
-}
-
-void SimpleEpollServer::VerifyReadyList() const {
- int count = 0;
- CBAndEventMask* cur = ready_list_.lh_first;
- for (; cur; cur = cur->entry.le_next) {
- ++count;
- }
- for (cur = tmp_list_.lh_first; cur; cur = cur->entry.le_next) {
- ++count;
- }
- CHECK_EQ(ready_list_size_, count) << "Ready list size does not match count";
-}
-
-void SimpleEpollServer::RegisterAlarm(int64_t timeout_time_in_us, AlarmCB* ac) {
- EPOLL_VLOG(4) << "RegisteringAlarm " << ac << " at : " << timeout_time_in_us;
- CHECK(ac);
- if (all_alarms_.find(ac) != all_alarms_.end()) {
- EPOLL_BUG(epoll_bug_1_1) << "Alarm already exists";
- }
-
- auto alarm_iter = alarm_map_.insert(std::make_pair(timeout_time_in_us, ac));
-
- all_alarms_.insert(ac);
- // Pass the iterator to the EpollAlarmCallbackInterface.
- ac->OnRegistration(alarm_iter, this);
-}
-
-// Unregister a specific alarm callback: iterator_token must be a
-// valid iterator. The caller must ensure the validity of the iterator.
-void SimpleEpollServer::UnregisterAlarm(const AlarmRegToken& iterator_token) {
- AlarmCB* cb = iterator_token->second;
- EPOLL_VLOG(4) << "UnregisteringAlarm " << cb;
- alarm_map_.erase(iterator_token);
- all_alarms_.erase(cb);
- cb->OnUnregistration();
-}
-
-SimpleEpollServer::AlarmRegToken SimpleEpollServer::ReregisterAlarm(
- SimpleEpollServer::AlarmRegToken iterator_token,
- int64_t timeout_time_in_us) {
- AlarmCB* cb = iterator_token->second;
- alarm_map_.erase(iterator_token);
- return alarm_map_.emplace(timeout_time_in_us, cb);
-}
-
-int SimpleEpollServer::NumFDsRegistered() const {
- DCHECK_GE(cb_map_.size(), 1u);
- // Omit the internal FD (read_fd_)
- return cb_map_.size() - 1;
-}
-
-void SimpleEpollServer::Wake() {
- char data = 'd'; // 'd' is for data. It's good enough for me.
- int rv = write(write_fd_, &data, 1);
- DCHECK_EQ(rv, 1);
-}
-
-int64_t SimpleEpollServer::NowInUsec() const {
- return absl::GetCurrentTimeNanos() / 1000;
-}
-
-int64_t SimpleEpollServer::ApproximateNowInUsec() const {
- if (recorded_now_in_us_ != 0) {
- return recorded_now_in_us_;
- }
- return this->NowInUsec();
-}
-
-std::string SimpleEpollServer::EventMaskToString(int event_mask) {
- std::string s;
- if (event_mask & EPOLLIN) s += "EPOLLIN ";
- if (event_mask & EPOLLPRI) s += "EPOLLPRI ";
- if (event_mask & EPOLLOUT) s += "EPOLLOUT ";
- if (event_mask & EPOLLRDNORM) s += "EPOLLRDNORM ";
- if (event_mask & EPOLLRDBAND) s += "EPOLLRDBAND ";
- if (event_mask & EPOLLWRNORM) s += "EPOLLWRNORM ";
- if (event_mask & EPOLLWRBAND) s += "EPOLLWRBAND ";
- if (event_mask & EPOLLMSG) s += "EPOLLMSG ";
- if (event_mask & EPOLLERR) s += "EPOLLERR ";
- if (event_mask & EPOLLHUP) s += "EPOLLHUP ";
- if (event_mask & EPOLLONESHOT) s += "EPOLLONESHOT ";
- if (event_mask & EPOLLET) s += "EPOLLET ";
- return s;
-}
-
-void SimpleEpollServer::LogStateOnCrash() {
- EPOLL_LOG(ERROR)
- << "-------------------Epoll Server-------------------------";
- EPOLL_LOG(ERROR) << "Epoll server " << this << " polling on fd " << epoll_fd_;
- EPOLL_LOG(ERROR) << "timeout_in_us_: " << timeout_in_us_;
-
- // Log sessions with alarms.
- EPOLL_LOG(ERROR) << alarm_map_.size() << " alarms registered.";
- for (auto it = alarm_map_.begin(); it != alarm_map_.end(); ++it) {
- const bool skipped =
- alarms_reregistered_and_should_be_skipped_.find(it->second) !=
- alarms_reregistered_and_should_be_skipped_.end();
- EPOLL_LOG(ERROR) << "Alarm " << it->second << " registered at time "
- << it->first << " and should be skipped = " << skipped;
- }
-
- EPOLL_LOG(ERROR) << cb_map_.size() << " fd callbacks registered.";
- for (auto it = cb_map_.begin(); it != cb_map_.end(); ++it) {
- EPOLL_LOG(ERROR) << "fd: " << it->fd << " with mask " << it->event_mask
- << " registered with cb: " << it->cb;
- }
- EPOLL_LOG(ERROR)
- << "-------------------/Epoll Server------------------------";
-}
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-void SimpleEpollServer::DelFD(int fd) const {
- struct epoll_event ee;
- memset(&ee, 0, sizeof(ee));
-#ifdef EPOLL_SERVER_EVENT_TRACING
- event_recorder_.RecordFDMaskEvent(fd, 0, "DelFD");
-#endif
- if (epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, &ee)) {
- int saved_errno = errno;
- char buf[kErrorBufferSize];
- EPOLL_LOG(FATAL) << "Epoll set removal error for fd " << fd << ": "
- << strerror_r(saved_errno, buf, sizeof(buf));
- }
-}
-
-////////////////////////////////////////
-
-void SimpleEpollServer::AddFD(int fd, int event_mask) const {
- struct epoll_event ee;
- memset(&ee, 0, sizeof(ee));
- ee.events = event_mask | EPOLLERR | EPOLLHUP;
- ee.data.fd = fd;
-#ifdef EPOLL_SERVER_EVENT_TRACING
- event_recorder_.RecordFDMaskEvent(fd, ee.events, "AddFD");
-#endif
- if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &ee)) {
- int saved_errno = errno;
- char buf[kErrorBufferSize];
- EPOLL_LOG(FATAL) << "Epoll set insertion error for fd " << fd << ": "
- << strerror_r(saved_errno, buf, sizeof(buf));
- }
-}
-
-////////////////////////////////////////
-
-void SimpleEpollServer::ModFD(int fd, int event_mask) const {
- struct epoll_event ee;
- memset(&ee, 0, sizeof(ee));
- ee.events = event_mask | EPOLLERR | EPOLLHUP;
- ee.data.fd = fd;
-#ifdef EPOLL_SERVER_EVENT_TRACING
- event_recorder_.RecordFDMaskEvent(fd, ee.events, "ModFD");
-#endif
- EPOLL_VLOG(3) << "modifying fd= " << fd << " "
- << EventMaskToString(ee.events);
- if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, fd, &ee)) {
- int saved_errno = errno;
- char buf[kErrorBufferSize];
- EPOLL_LOG(FATAL) << "Epoll set modification error for fd " << fd << ": "
- << strerror_r(saved_errno, buf, sizeof(buf));
- }
-}
-
-////////////////////////////////////////
-
-void SimpleEpollServer::ModifyFD(int fd, int remove_event, int add_event) {
- auto fd_i = cb_map_.find(CBAndEventMask(NULL, 0, fd));
- if (cb_map_.end() == fd_i) {
- EPOLL_VLOG(2) << "Didn't find the fd " << fd << "in internal structures";
- return;
- }
-
- if (fd_i->cb != NULL) {
- int& event_mask = fd_i->event_mask;
- EPOLL_VLOG(3) << "fd= " << fd
- << " event_mask before: " << EventMaskToString(event_mask);
- event_mask &= ~remove_event;
- event_mask |= add_event;
-
- EPOLL_VLOG(3) << " event_mask after: " << EventMaskToString(event_mask);
-
- ModFD(fd, event_mask);
-
- fd_i->cb->OnModification(fd, event_mask);
- }
-}
-
-void SimpleEpollServer::WaitForEventsAndCallHandleEvents(
- int64_t timeout_in_us, struct epoll_event events[], int events_size) {
- if (timeout_in_us == 0 || ready_list_.lh_first != NULL) {
- // If ready list is not empty, then don't sleep at all.
- timeout_in_us = 0;
- } else if (timeout_in_us < 0) {
- EPOLL_LOG(INFO) << "Negative epoll timeout: " << timeout_in_us
- << "us; epoll will wait forever for events.";
- // If timeout_in_us is < 0 we are supposed to Wait forever. This means we
- // should set timeout_in_us to -1000 so we will
- // Wait(-1000/1000) == Wait(-1) == Wait forever.
- timeout_in_us = -1000;
- } else {
- // If timeout is specified, and the ready list is empty.
- if (timeout_in_us < 1000) {
- timeout_in_us = 1000;
- }
- }
- const int timeout_in_ms = timeout_in_us / 1000;
- int64_t expected_wakeup_us = NowInUsec() + timeout_in_us;
-
- int nfds = epoll_wait_impl(epoll_fd_, events, events_size, timeout_in_ms);
- EPOLL_VLOG(3) << "nfds=" << nfds;
-
-#ifdef EPOLL_SERVER_EVENT_TRACING
- event_recorder_.RecordEpollWaitEvent(timeout_in_ms, nfds);
-#endif
-
- // If you're wondering why the NowInUsec() is recorded here, the answer is
- // simple: If we did it before the epoll_wait_impl, then the max error for
- // the ApproximateNowInUs() call would be as large as the maximum length of
- // epoll_wait, which can be arbitrarily long. Since this would make
- // ApproximateNowInUs() worthless, we instead record the time -after- we've
- // done epoll_wait, which guarantees that the maximum error is the amount of
- // time it takes to process all the events generated by epoll_wait.
- recorded_now_in_us_ = NowInUsec();
-
- if (timeout_in_us > 0) {
- int64_t delta = NowInUsec() - expected_wakeup_us;
- last_delay_in_usec_ = delta > 0 ? delta : 0;
- } else {
- // timeout_in_us < 0 means we waited forever until an event;
- // timeout_in_us == 0 means there was no kernel delay to track.
- last_delay_in_usec_ = 0;
- }
-
- if (nfds > 0) {
- for (int i = 0; i < nfds; ++i) {
- int event_mask = events[i].events;
- int fd = events[i].data.fd;
- HandleEvent(fd, event_mask);
- }
- } else if (nfds < 0) {
- // Catch interrupted syscall and just ignore it and move on.
- if (errno != EINTR && errno != 0) {
- int saved_errno = errno;
- char buf[kErrorBufferSize];
- EPOLL_LOG(FATAL) << "Error " << saved_errno << " in epoll_wait: "
- << strerror_r(saved_errno, buf, sizeof(buf));
- }
- }
-
- // Now run through the ready list.
- if (ready_list_.lh_first) {
- CallReadyListCallbacks();
- }
-}
-
-void SimpleEpollServer::CallReadyListCallbacks() {
- // Check pre-conditions.
- DCHECK(tmp_list_.lh_first == NULL);
- // Swap out the ready_list_ into the tmp_list_ before traversing the list to
- // enable SetFDReady() to just push new items into the ready_list_.
- std::swap(ready_list_.lh_first, tmp_list_.lh_first);
- if (tmp_list_.lh_first) {
- tmp_list_.lh_first->entry.le_prev = &tmp_list_.lh_first;
- EpollEvent event(0);
- while (tmp_list_.lh_first != NULL) {
- DCHECK_GT(ready_list_size_, 0);
- CBAndEventMask* cb_and_mask = tmp_list_.lh_first;
- RemoveFromReadyList(*cb_and_mask);
-
- event.out_ready_mask = 0;
- event.in_events =
- cb_and_mask->events_asserted | cb_and_mask->events_to_fake;
- // TODO(fenix): get rid of the two separate fields in cb_and_mask.
- cb_and_mask->events_asserted = 0;
- cb_and_mask->events_to_fake = 0;
- {
- // OnEvent() may call UnRegister, so we set in_use, here. Any
- // UnRegister call will now simply set the cb to NULL instead of
- // invalidating the cb_and_mask object (by deleting the object in the
- // map to which cb_and_mask refers)
- AutoReset<bool> in_use_guard(&(cb_and_mask->in_use), true);
- cb_and_mask->cb->OnEvent(cb_and_mask->fd, &event);
- }
-
- // Since OnEvent may have called UnregisterFD, we must check here that
- // the callback is still valid. If it isn't, then UnregisterFD *was*
- // called, and we should now get rid of the object.
- if (cb_and_mask->cb == NULL) {
- cb_map_.erase(*cb_and_mask);
- } else if (event.out_ready_mask != 0) {
- cb_and_mask->events_to_fake = event.out_ready_mask;
- AddToReadyList(cb_and_mask);
- }
- }
- }
- DCHECK(tmp_list_.lh_first == NULL);
-}
-
-void SimpleEpollServer::CallAndReregisterAlarmEvents() {
- int64_t now_in_us = recorded_now_in_us_;
- DCHECK_NE(0, recorded_now_in_us_);
-
- TimeToAlarmCBMap::iterator erase_it;
-
- // execute alarms.
- for (auto i = alarm_map_.begin(); i != alarm_map_.end();) {
- if (i->first > now_in_us) {
- break;
- }
- AlarmCB* cb = i->second;
- // Execute the OnAlarm() only if we did not register
- // it in this loop itself.
- const bool added_in_this_round =
- alarms_reregistered_and_should_be_skipped_.find(cb) !=
- alarms_reregistered_and_should_be_skipped_.end();
- if (added_in_this_round) {
- ++i;
- continue;
- }
- all_alarms_.erase(cb);
- const int64_t new_timeout_time_in_us = cb->OnAlarm();
-
- erase_it = i;
- ++i;
- alarm_map_.erase(erase_it);
-
- if (new_timeout_time_in_us > 0) {
- // We add to hash_set only if the new timeout is <= now_in_us.
- // if timeout is > now_in_us then we have no fear that this alarm
- // can be reexecuted in this loop, and hence we do not need to
- // worry about a recursive loop.
- EPOLL_DVLOG(3) << "Reregistering alarm "
- << " " << cb << " " << new_timeout_time_in_us << " "
- << now_in_us;
- if (new_timeout_time_in_us <= now_in_us) {
- alarms_reregistered_and_should_be_skipped_.insert(cb);
- }
- RegisterAlarm(new_timeout_time_in_us, cb);
- }
- }
- alarms_reregistered_and_should_be_skipped_.clear();
-}
-
-EpollAlarm::EpollAlarm() : eps_(NULL), registered_(false) {}
-
-EpollAlarm::~EpollAlarm() { UnregisterIfRegistered(); }
-
-int64_t EpollAlarm::OnAlarm() {
- registered_ = false;
- return 0;
-}
-
-void EpollAlarm::OnRegistration(const SimpleEpollServer::AlarmRegToken& token,
- SimpleEpollServer* eps) {
- DCHECK_EQ(false, registered_);
-
- token_ = token;
- eps_ = eps;
- registered_ = true;
-}
-
-void EpollAlarm::OnUnregistration() { registered_ = false; }
-
-void EpollAlarm::OnShutdown(SimpleEpollServer* /*eps*/) {
- registered_ = false;
- eps_ = NULL;
-}
-
-// If the alarm was registered, unregister it.
-void EpollAlarm::UnregisterIfRegistered() {
- if (!registered_) {
- return;
- }
-
- eps_->UnregisterAlarm(token_);
-}
-
-void EpollAlarm::ReregisterAlarm(int64_t timeout_time_in_us) {
- DCHECK(registered_);
- token_ = eps_->ReregisterAlarm(token_, timeout_time_in_us);
-}
-
-} // namespace epoll_server
diff --git a/quiche/epoll_server/simple_epoll_server.h b/quiche/epoll_server/simple_epoll_server.h
deleted file mode 100644
index 405e306..0000000
--- a/quiche/epoll_server/simple_epoll_server.h
+++ /dev/null
@@ -1,1051 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_EPOLL_SERVER_SIMPLE_EPOLL_SERVER_H_
-#define QUICHE_EPOLL_SERVER_SIMPLE_EPOLL_SERVER_H_
-
-#include <fcntl.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/queue.h>
-
-#include <map>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-// #define EPOLL_SERVER_EVENT_TRACING 1
-//
-// Defining EPOLL_SERVER_EVENT_TRACING
-// causes code to exist which didn't before.
-// This code tracks each event generated by the epollserver,
-// as well as providing a per-fd-registered summary of
-// events. Note that enabling this code vastly slows
-// down operations, and uses substantially more
-// memory. For these reasons, it should only be enabled by developers doing
-// development at their workstations.
-//
-// A structure called 'EventRecorder' will exist when
-// the macro is defined. See the EventRecorder class interface
-// within the SimpleEpollServer class for more details.
-#ifdef EPOLL_SERVER_EVENT_TRACING
-#include <ostream>
-#endif
-
-#include <sys/epoll.h>
-
-#include "quiche/epoll_server/platform/api/epoll_logging.h"
-
-namespace epoll_server {
-
-class SimpleEpollServer;
-class EpollAlarmCallbackInterface;
-class ReadPipeCallback;
-
-struct EpollEvent {
- EpollEvent(int events) : in_events(events), out_ready_mask(0) {}
-
- int in_events; // incoming events
- int out_ready_mask; // the new event mask for ready list (0 means don't
- // get on the ready list). This field is always
- // initialized to 0 when the event is passed to
- // OnEvent.
-};
-
-// Callbacks which go into SimpleEpollServers are expected to derive from this
-// class.
-class EpollCallbackInterface {
- public:
- // Summary:
- // Called when the callback is registered into a SimpleEpollServer.
- // Args:
- // eps - the poll server into which this callback was registered
- // fd - the file descriptor which was registered
- // event_mask - the event mask (composed of EPOLLIN, EPOLLOUT, etc)
- // which was registered (and will initially be used
- // in the epoll() calls)
- virtual void OnRegistration(SimpleEpollServer* eps, int fd,
- int event_mask) = 0;
-
- // Summary:
- // Called when the event_mask is modified (for a file-descriptor)
- // Args:
- // fd - the file descriptor which was registered
- // event_mask - the event mask (composed of EPOLLIN, EPOLLOUT, etc)
- // which was is now curren (and will be used
- // in subsequent epoll() calls)
- virtual void OnModification(int fd, int event_mask) = 0;
-
- // Summary:
- // Called whenever an event occurs on the file-descriptor.
- // This is where the bulk of processing is expected to occur.
- // Args:
- // fd - the file descriptor which was registered
- // event - a struct that contains the event mask (composed of EPOLLIN,
- // EPOLLOUT, etc), a flag that indicates whether this is a true
- // epoll_wait event vs one from the ready list, and an output
- // parameter for OnEvent to inform the SimpleEpollServer whether to
- // put this fd on the ready list.
- virtual void OnEvent(int fd, EpollEvent* event) = 0;
-
- // Summary:
- // Called when the file-descriptor is unregistered from the poll-server.
- // Args:
- // fd - the file descriptor which was registered, and of this call, is now
- // unregistered.
- // replaced - If true, this callback is being replaced by another, otherwise
- // it is simply being removed.
- virtual void OnUnregistration(int fd, bool replaced) = 0;
-
- // Summary:
- // Called when the epoll server is shutting down. This is different from
- // OnUnregistration because the subclass may want to clean up memory.
- // This is called in leiu of OnUnregistration.
- // Args:
- // fd - the file descriptor which was registered.
- virtual void OnShutdown(SimpleEpollServer* eps, int fd) = 0;
-
- // Summary:
- // Returns a name describing the class for use in debug/error reporting.
- virtual std::string Name() const = 0;
-
- virtual ~EpollCallbackInterface() {}
-
- protected:
- EpollCallbackInterface() {}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-class SimpleEpollServer {
- public:
- typedef EpollAlarmCallbackInterface AlarmCB;
- typedef EpollCallbackInterface CB;
-
- typedef std::multimap<int64_t, AlarmCB*> TimeToAlarmCBMap;
- typedef TimeToAlarmCBMap::iterator AlarmRegToken;
-
- // Summary:
- // Constructor:
- // By default, we don't wait any amount of time for events, and
- // we suggest to the epoll-system that we're going to use on-the-order
- // of 1024 FDs.
- SimpleEpollServer();
-
- SimpleEpollServer(const SimpleEpollServer&) = delete;
- SimpleEpollServer operator=(const SimpleEpollServer&) = delete;
-
- ////////////////////////////////////////
-
- // Destructor
- virtual ~SimpleEpollServer();
-
- ////////////////////////////////////////
-
- // Summary
- // Register a callback to be called whenever an event contained
- // in the set of events included in event_mask occurs on the
- // file-descriptor 'fd'
- //
- // Note that only one callback is allowed to be registered for
- // any specific file-decriptor.
- //
- // If a callback is registered for a file-descriptor which has already
- // been registered, then the previous callback is unregistered with
- // the 'replaced' flag set to true. I.e. the previous callback's
- // OnUnregistration() function is called like so:
- // OnUnregistration(fd, true);
- //
- // The epoll server does NOT take on ownership of the callback: the callback
- // creator is responsible for managing that memory.
- //
- // Args:
- // fd - a valid file-descriptor
- // cb - an instance of a subclass of EpollCallbackInterface
- // event_mask - a combination of (EPOLLOUT, EPOLLIN.. etc) indicating
- // the events for which the callback would like to be
- // called.
- virtual void RegisterFD(int fd, CB* cb, int event_mask);
-
- ////////////////////////////////////////
-
- // Summary:
- // A shortcut for RegisterFD which sets things up such that the
- // callback is called when 'fd' is available for writing.
- // Args:
- // fd - a valid file-descriptor
- // cb - an instance of a subclass of EpollCallbackInterface
- virtual void RegisterFDForWrite(int fd, CB* cb);
-
- ////////////////////////////////////////
-
- // Summary:
- // A shortcut for RegisterFD which sets things up such that the
- // callback is called when 'fd' is available for reading or writing.
- // Args:
- // fd - a valid file-descriptor
- // cb - an instance of a subclass of EpollCallbackInterface
- virtual void RegisterFDForReadWrite(int fd, CB* cb);
-
- ////////////////////////////////////////
-
- // Summary:
- // A shortcut for RegisterFD which sets things up such that the
- // callback is called when 'fd' is available for reading.
- // Args:
- // fd - a valid file-descriptor
- // cb - an instance of a subclass of EpollCallbackInterface
- virtual void RegisterFDForRead(int fd, CB* cb);
-
- ////////////////////////////////////////
-
- // Summary:
- // Removes the FD and the associated callback from the pollserver.
- // If the callback is registered with other FDs, they will continue
- // to be processed using the callback without modification.
- // If the file-descriptor specified is not registered in the
- // epoll_server, then nothing happens as a result of this call.
- // Args:
- // fd - the file-descriptor which should no-longer be monitored.
- virtual void UnregisterFD(int fd);
-
- ////////////////////////////////////////
-
- // Summary:
- // Modifies the event mask for the file-descriptor, replacing
- // the old event_mask with the new one specified here.
- // If the file-descriptor specified is not registered in the
- // epoll_server, then nothing happens as a result of this call.
- // Args:
- // fd - the fd whose event mask should be modified.
- // event_mask - the new event mask.
- virtual void ModifyCallback(int fd, int event_mask);
-
- ////////////////////////////////////////
-
- // Summary:
- // Modifies the event mask for the file-descriptor such that we
- // no longer request events when 'fd' is readable.
- // If the file-descriptor specified is not registered in the
- // epoll_server, then nothing happens as a result of this call.
- // Args:
- // fd - the fd whose event mask should be modified.
- virtual void StopRead(int fd);
-
- ////////////////////////////////////////
-
- // Summary:
- // Modifies the event mask for the file-descriptor such that we
- // request events when 'fd' is readable.
- // If the file-descriptor specified is not registered in the
- // epoll_server, then nothing happens as a result of this call.
- // Args:
- // fd - the fd whose event mask should be modified.
- virtual void StartRead(int fd);
-
- ////////////////////////////////////////
-
- // Summary:
- // Modifies the event mask for the file-descriptor such that we
- // no longer request events when 'fd' is writable.
- // If the file-descriptor specified is not registered in the
- // epoll_server, then nothing happens as a result of this call.
- // Args:
- // fd - the fd whose event mask should be modified.
- virtual void StopWrite(int fd);
-
- ////////////////////////////////////////
-
- // Summary:
- // Modifies the event mask for the file-descriptor such that we
- // request events when 'fd' is writable.
- // If the file-descriptor specified is not registered in the
- // epoll_server, then nothing happens as a result of this call.
- // Args:
- // fd - the fd whose event mask should be modified.
- virtual void StartWrite(int fd);
-
- ////////////////////////////////////////
-
- // Summary:
- // Looks up the callback associated with the file-descriptor 'fd'.
- // If a callback is associated with this file-descriptor, then
- // it's OnEvent() method is called with the file-descriptor 'fd',
- // and event_mask 'event_mask'
- //
- // If no callback is registered for this file-descriptor, nothing
- // will happen as a result of this call.
- //
- // This function is used internally by the SimpleEpollServer, but is
- // available publicly so that events might be 'faked'. Calling
- // this function with an fd and event_mask is equivalent (as far
- // as the callback is concerned) to having a real event generated
- // by epoll (except, of course, that read(), etc won't necessarily
- // be able to read anything)
- // Args:
- // fd - the file-descriptor on which an event has occurred.
- // event_mask - a bitmask representing the events which have occurred
- // on/for this fd. This bitmask is composed of
- // POLLIN, POLLOUT, etc.
- //
- void HandleEvent(int fd, int event_mask);
-
- // Summary:
- // Call this when you want the pollserver to
- // wait for events and execute the callbacks associated with
- // the file-descriptors on which those events have occurred.
- // Depending on the value of timeout_in_us_, this may or may
- // not return immediately. Please reference the set_timeout()
- // function for the specific behaviour.
- virtual void WaitForEventsAndExecuteCallbacks();
-
- // Summary:
- // When an fd is registered to use edge trigger notification, the ready
- // list can be used to simulate level trigger semantics. Edge trigger
- // registration doesn't send an initial event, and only rising edge (going
- // from blocked to unblocked) events are sent. A callback can put itself on
- // the ready list by calling SetFDReady() after calling RegisterFD(). The
- // OnEvent method of all callbacks associated with the fds on the ready
- // list will be called immediately after processing the events returned by
- // epoll_wait(). The fd is removed from the ready list before the
- // callback's OnEvent() method is invoked. To stay on the ready list, the
- // OnEvent() (or some function in that call chain) must call SetFDReady
- // again. When a fd is unregistered using UnregisterFD(), the fd is
- // automatically removed from the ready list.
- //
- // When the callback for a edge triggered fd hits the falling edge (about
- // to block, either because of it got an EAGAIN, or had a short read/write
- // operation), it should remove itself from the ready list using
- // SetFDNotReady() (since OnEvent cannot distinguish between invocation
- // from the ready list vs from a normal epoll event). All four ready list
- // methods are safe to be called within the context of the callbacks.
- //
- // Since the ready list invokes EpollCallbackInterface::OnEvent, only fds
- // that are registered with the SimpleEpollServer will be put on the ready
- // list. SetFDReady() and SetFDNotReady() will do nothing if the
- // SimpleEpollServer doesn't know about the fd passed in.
- //
- // Since the ready list cannot reliably determine proper set of events
- // which should be sent to the callback, SetFDReady() requests the caller
- // to provide the ready list with the event mask, which will be used later
- // when OnEvent() is invoked by the ready list. Hence, the event_mask
- // passedto SetFDReady() does not affect the actual epoll registration of
- // the fd with the kernel. If a fd is already put on the ready list, and
- // SetFDReady() is called again for that fd with a different event_mask,
- // the event_mask will be updated.
- virtual void SetFDReady(int fd, int events_to_fake);
-
- virtual void SetFDNotReady(int fd);
-
- // Summary:
- // IsFDReady(), ReadyListSize(), and VerifyReadyList are intended as
- // debugging tools and for writing unit tests.
- // ISFDReady() returns whether a fd is in the ready list.
- // ReadyListSize() returns the number of fds on the ready list.
- // VerifyReadyList() checks the consistency of internal data structure. It
- // will CHECK if it finds an error.
- virtual bool IsFDReady(int fd) const;
-
- size_t ReadyListSize() const { return ready_list_size_; }
-
- void VerifyReadyList() const;
-
- ////////////////////////////////////////
-
- // Summary:
- // Registers an alarm 'ac' to go off at time 'timeout_time_in_us'.
- // If the callback returns a positive number from its OnAlarm() function,
- // then the callback will be re-registered at that time, else the alarm
- // owner is responsible for freeing up memory.
- //
- // Important: A give AlarmCB* can not be registered again if it is already
- // registered. If a user wants to register a callback again it should first
- // unregister the previous callback before calling RegisterAlarm again.
- // Args:
- // timeout_time_in_us - the absolute time at which the alarm should go off
- // ac - the alarm which will be called.
- virtual void RegisterAlarm(int64_t timeout_time_in_us, AlarmCB* ac);
-
- // Summary:
- // Registers an alarm 'ac' to go off at time: (ApproximateNowInUs() +
- // delta_in_us). While this is somewhat less accurate (see the description
- // for ApproximateNowInUs() to see how 'approximate'), the error is never
- // worse than the amount of time it takes to process all events in one
- // WaitForEvents. As with 'RegisterAlarm()', if the callback returns a
- // positive number from its OnAlarm() function, then the callback will be
- // re-registered at that time, else the alarm owner is responsible for
- // freeing up memory.
- // Note that this function is purely a convienence. The
- // same thing may be accomplished by using RegisterAlarm with
- // ApproximateNowInUs() directly.
- //
- // Important: A give AlarmCB* can not be registered again if it is already
- // registered. If a user wants to register a callback again it should first
- // unregister the previous callback before calling RegisterAlarm again.
- // Args:
- // delta_in_us - the delta in microseconds from the ApproximateTimeInUs() at
- // which point the alarm should go off.
- // ac - the alarm which will be called.
- void RegisterAlarmApproximateDelta(int64_t delta_in_us, AlarmCB* ac) {
- RegisterAlarm(ApproximateNowInUsec() + delta_in_us, ac);
- }
-
- ////////////////////////////////////////
-
- // Summary:
- // Unregister the alarm referred to by iterator_token; Callers should
- // be warned that a token may have become already invalid when OnAlarm()
- // is called, was unregistered, or OnShutdown was called on that alarm.
- // Args:
- // iterator_token - iterator to the alarm callback to unregister.
- virtual void UnregisterAlarm(
- const SimpleEpollServer::AlarmRegToken& iterator_token);
-
- virtual SimpleEpollServer::AlarmRegToken ReregisterAlarm(
- SimpleEpollServer::AlarmRegToken iterator_token,
- int64_t timeout_time_in_us);
-
- ////////////////////////////////////////
-
- // Summary:
- // returns the number of file-descriptors registered in this
- // SimpleEpollServer.
- // Returns:
- // number of FDs registered (discounting the internal pipe used for Wake)
- virtual int NumFDsRegistered() const;
-
- // Summary:
- // Force the epoll server to wake up (by writing to an internal pipe).
- virtual void Wake();
-
- // Summary:
- // Wrapper around WallTimer's NowInUsec. We do this so that we can test
- // SimpleEpollServer without using the system clock (and can avoid the
- // flakiness that would ensue)
- // Returns:
- // the current time as number of microseconds since the Unix epoch.
- virtual int64_t NowInUsec() const;
-
- // Summary:
- // Since calling NowInUsec() many thousands of times per
- // WaitForEventsAndExecuteCallbacks function call is, to say the least,
- // inefficient, we allow users to use an approximate time instead. The
- // time returned from this function is as accurate as NowInUsec() when
- // WaitForEventsAndExecuteCallbacks is not an ancestor of the caller's
- // callstack.
- // However, when WaitForEventsAndExecuteCallbacks -is- an ancestor, then
- // this function returns the time at which the
- // WaitForEventsAndExecuteCallbacks function started to process events or
- // alarms.
- //
- // Essentially, this function makes available a fast and mostly accurate
- // mechanism for getting the time for any function handling an event or
- // alarm. When functions which are not handling callbacks or alarms call
- // this function, they get the slow and "absolutely" accurate time.
- //
- // Users should be encouraged to use this function.
- // Returns:
- // the "approximate" current time as number of microseconds since the Unix
- // epoch.
- virtual int64_t ApproximateNowInUsec() const;
-
- static std::string EventMaskToString(int event_mask);
-
- // Summary:
- // Logs the state of the epoll server with EPOLL_LOG(ERROR).
- void LogStateOnCrash();
-
- // Summary:
- // Set the timeout to the value specified.
- // If the timeout is set to a negative number,
- // WaitForEventsAndExecuteCallbacks() will only return when an event has
- // occurred
- // If the timeout is set to zero,
- // WaitForEventsAndExecuteCallbacks() will return immediately
- // If the timeout is set to a positive number,
- // WaitForEventsAndExecuteCallbacks() will return when an event has
- // occurred, or when timeout_in_us microseconds has elapsed, whichever
- // is first.
- // Args:
- // timeout_in_us - value specified depending on behaviour desired.
- // See above.
- void set_timeout_in_us(int64_t timeout_in_us) {
- timeout_in_us_ = timeout_in_us;
- }
-
- ////////////////////////////////////////
-
- // Summary:
- // Accessor for the current value of timeout_in_us.
- int timeout_in_us_for_test() const { return timeout_in_us_; }
-
- // Summary:
- // Returns true when the SimpleEpollServer() is being destroyed.
- bool in_shutdown() const { return in_shutdown_; }
- bool ShutdownCalled() const { return in_shutdown(); }
-
- // Compatibility stub.
- void Shutdown() {}
-
- // Summary:
- // A function for implementing the ready list. It invokes OnEvent for each
- // of the fd in the ready list, and takes care of adding them back to the
- // ready list if the callback requests it (by checking that out_ready_mask
- // is non-zero).
- void CallReadyListCallbacks();
-
- int64_t LastDelayInUsec() const { return last_delay_in_usec_; }
-
- protected:
- virtual void SetNonblocking(int fd);
-
- // This exists here so that we can override this function in unittests
- // in order to make effective mock SimpleEpollServer objects.
- virtual int epoll_wait_impl(int epfd, struct epoll_event* events,
- int max_events, int timeout_in_ms);
-
- // this struct is used internally, and is never used by anything external
- // to this class. Some of its members are declared mutable to get around the
- // restriction imposed by hash_set. Since hash_set knows nothing about the
- // objects it stores, it has to assume that every bit of the object is used
- // in the hash function and equal_to comparison. Thus hash_set::iterator is a
- // const iterator. In this case, the only thing that must stay constant is
- // fd. Everything else are just along for the ride and changing them doesn't
- // compromise the hash_set integrity.
- struct CBAndEventMask {
- CBAndEventMask()
- : cb(NULL),
- fd(-1),
- event_mask(0),
- events_asserted(0),
- events_to_fake(0),
- in_use(false) {
- entry.le_next = NULL;
- entry.le_prev = NULL;
- }
-
- CBAndEventMask(EpollCallbackInterface* cb, int event_mask, int fd)
- : cb(cb),
- fd(fd),
- event_mask(event_mask),
- events_asserted(0),
- events_to_fake(0),
- in_use(false) {
- entry.le_next = NULL;
- entry.le_prev = NULL;
- }
-
- // Required operator for hash_set. Normally operator== should be a free
- // standing function. However, since CBAndEventMask is a protected type and
- // it will never be a base class, it makes no difference.
- bool operator==(const CBAndEventMask& cb_and_mask) const {
- return fd == cb_and_mask.fd;
- }
- // A callback. If the fd is unregistered inside the callchain of OnEvent,
- // the cb will be set to NULL.
- mutable EpollCallbackInterface* cb;
-
- mutable LIST_ENTRY(CBAndEventMask) entry;
- // file descriptor registered with the epoll server.
- int fd;
- // the current event_mask registered for this callback.
- mutable int event_mask;
- // the event_mask that was returned by epoll
- mutable int events_asserted;
- // the event_mask for the ready list to use to call OnEvent.
- mutable int events_to_fake;
- // toggle around calls to OnEvent to tell UnregisterFD to not erase the
- // iterator because HandleEvent is using it.
- mutable bool in_use;
- };
-
- // Custom hash function to be used by hash_set.
- struct CBAndEventMaskHash {
- size_t operator()(const CBAndEventMask& cb_and_eventmask) const {
- return static_cast<size_t>(cb_and_eventmask.fd);
- }
- };
-
- using FDToCBMap = std::unordered_set<CBAndEventMask, CBAndEventMaskHash>;
-
- // the following four functions are OS-specific, and are likely
- // to be changed in a subclass if the poll/select method is changed
- // from epoll.
-
- // Summary:
- // Deletes a file-descriptor from the set of FDs that should be
- // monitored with epoll.
- // Note that this only deals with modifying data relating -directly-
- // with the epoll call-- it does not modify any data within the
- // epoll_server.
- // Args:
- // fd - the file descriptor to-be-removed from the monitoring set
- virtual void DelFD(int fd) const;
-
- ////////////////////////////////////////
-
- // Summary:
- // Adds a file-descriptor to the set of FDs that should be
- // monitored with epoll.
- // Note that this only deals with modifying data relating -directly-
- // with the epoll call.
- // Args:
- // fd - the file descriptor to-be-added to the monitoring set
- // event_mask - the event mask (consisting of EPOLLIN, EPOLLOUT, etc
- // OR'd together) which will be associated with this
- // FD initially.
- virtual void AddFD(int fd, int event_mask) const;
-
- ////////////////////////////////////////
-
- // Summary:
- // Modifies a file-descriptor in the set of FDs that should be
- // monitored with epoll.
- // Note that this only deals with modifying data relating -directly-
- // with the epoll call.
- // Args:
- // fd - the file descriptor to-be-added to the monitoring set
- // event_mask - the event mask (consisting of EPOLLIN, EPOLLOUT, etc
- // OR'd together) which will be associated with this
- // FD after this call.
- virtual void ModFD(int fd, int event_mask) const;
-
- ////////////////////////////////////////
-
- // Summary:
- // Modified the event mask associated with an FD in the set of
- // data needed by epoll.
- // Events are removed before they are added, thus, if ~0 is put
- // in 'remove_event', whatever is put in 'add_event' will be
- // the new event mask.
- // If the file-descriptor specified is not registered in the
- // epoll_server, then nothing happens as a result of this call.
- // Args:
- // fd - the file descriptor whose event mask is to be modified
- // remove_event - the events which are to be removed from the current
- // event_mask
- // add_event - the events which are to be added to the current event_mask
- //
- //
- virtual void ModifyFD(int fd, int remove_event, int add_event);
-
- ////////////////////////////////////////
-
- // Summary:
- // Waits for events, and calls HandleEvents() for each
- // fd, event pair discovered to possibly have an event.
- // Note that a callback (B) may get a spurious event if
- // another callback (A) has closed a file-descriptor N, and
- // the callback (B) has a newly opened file-descriptor, which
- // also happens to be N.
- virtual void WaitForEventsAndCallHandleEvents(int64_t timeout_in_us,
- struct epoll_event events[],
- int events_size);
-
- // Summary:
- // An internal function for implementing the ready list. It adds a fd's
- // CBAndEventMask to the ready list. If the fd is already on the ready
- // list, it is a no-op.
- void AddToReadyList(CBAndEventMask* cb_and_mask);
-
- // Summary:
- // An internal function for implementing the ready list. It remove a fd's
- // CBAndEventMask from the ready list. If the fd is not on the ready list,
- // it is a no-op.
- void RemoveFromReadyList(const CBAndEventMask& cb_and_mask);
-
- // Summary:
- // Calls any pending alarms that should go off and reregisters them if they
- // were recurring.
- virtual void CallAndReregisterAlarmEvents();
-
- // The file-descriptor created for epolling
- int epoll_fd_;
-
- // The mapping of file-descriptor to CBAndEventMasks
- FDToCBMap cb_map_;
-
- // Custom hash function to be used by hash_set.
- struct AlarmCBHash {
- size_t operator()(AlarmCB* const& p) const {
- return reinterpret_cast<size_t>(p);
- }
- };
-
- // TODO(sushantj): Having this hash_set is avoidable. We currently have it
- // only so that we can enforce stringent checks that a caller can not register
- // the same alarm twice. One option is to have an implementation in which
- // this hash_set is used only in the debug mode.
- using AlarmCBMap = std::unordered_set<AlarmCB*, AlarmCBHash>;
- AlarmCBMap all_alarms_;
-
- TimeToAlarmCBMap alarm_map_;
-
- // The amount of time in microseconds that we'll wait before returning
- // from the WaitForEventsAndExecuteCallbacks() function.
- // If this is positive, wait that many microseconds.
- // If this is negative, wait forever, or for the first event that occurs
- // If this is zero, never wait for an event.
- int64_t timeout_in_us_;
-
- // This is nonzero only after the invocation of epoll_wait_impl within
- // WaitForEventsAndCallHandleEvents and before the function
- // WaitForEventsAndExecuteCallbacks returns. At all other times, this is
- // zero. This enables us to have relatively accurate time returned from the
- // ApproximateNowInUs() function. See that function for more details.
- int64_t recorded_now_in_us_;
-
- // This is used to implement CallAndReregisterAlarmEvents. This stores
- // all alarms that were reregistered because OnAlarm() returned a
- // value > 0 and the time at which they should be executed is less that
- // the current time. By storing such alarms in this map we ensure
- // that while calling CallAndReregisterAlarmEvents we do not call
- // OnAlarm on any alarm in this set. This ensures that we do not
- // go in an infinite loop.
- AlarmCBMap alarms_reregistered_and_should_be_skipped_;
-
- LIST_HEAD(ReadyList, CBAndEventMask) ready_list_;
- LIST_HEAD(TmpList, CBAndEventMask) tmp_list_;
- int ready_list_size_;
- // TODO(alyssar): make this into something that scales up.
- static const int events_size_ = 256;
- struct epoll_event events_[256];
-
-#ifdef EPOLL_SERVER_EVENT_TRACING
- struct EventRecorder {
- public:
- EventRecorder() : num_records_(0), record_threshold_(10000) {}
-
- ~EventRecorder() { Clear(); }
-
- // When a number of events equals the record threshold,
- // the collected data summary for all FDs will be written
- // to EPOLL_LOG(INFO). Note that this does not include the
- // individual events (if you'reinterested in those, you'll
- // have to get at them programmatically).
- // After any such flushing to EPOLL_LOG(INFO) all events will
- // be cleared.
- // Note that the definition of an 'event' is a bit 'hazy',
- // as it includes the 'Unregistration' event, and perhaps
- // others.
- void set_record_threshold(int64_t new_threshold) {
- record_threshold_ = new_threshold;
- }
-
- void Clear() {
- for (int i = 0; i < debug_events_.size(); ++i) {
- delete debug_events_[i];
- }
- debug_events_.clear();
- unregistered_fds_.clear();
- event_counts_.clear();
- }
-
- void MaybeRecordAndClear() {
- ++num_records_;
- if ((num_records_ > record_threshold_) && (record_threshold_ > 0)) {
- EPOLL_LOG(INFO) << "\n" << *this;
- num_records_ = 0;
- Clear();
- }
- }
-
- void RecordFDMaskEvent(int fd, int mask, const char* function) {
- FDMaskOutput* fdmo = new FDMaskOutput(fd, mask, function);
- debug_events_.push_back(fdmo);
- MaybeRecordAndClear();
- }
-
- void RecordEpollWaitEvent(int timeout_in_ms, int num_events_generated) {
- EpollWaitOutput* ewo =
- new EpollWaitOutput(timeout_in_ms, num_events_generated);
- debug_events_.push_back(ewo);
- MaybeRecordAndClear();
- }
-
- void RecordEpollEvent(int fd, int event_mask) {
- Events& events_for_fd = event_counts_[fd];
- events_for_fd.AssignFromMask(event_mask);
- MaybeRecordAndClear();
- }
-
- friend ostream& operator<<(ostream& os, const EventRecorder& er) {
- for (int i = 0; i < er.unregistered_fds_.size(); ++i) {
- os << "fd: " << er.unregistered_fds_[i] << "\n";
- os << er.unregistered_fds_[i];
- }
- for (EventCountsMap::const_iterator i = er.event_counts_.begin();
- i != er.event_counts_.end(); ++i) {
- os << "fd: " << i->first << "\n";
- os << i->second;
- }
- for (int i = 0; i < er.debug_events_.size(); ++i) {
- os << *(er.debug_events_[i]) << "\n";
- }
- return os;
- }
-
- void RecordUnregistration(int fd) {
- EventCountsMap::iterator i = event_counts_.find(fd);
- if (i != event_counts_.end()) {
- unregistered_fds_.push_back(i->second);
- event_counts_.erase(i);
- }
- MaybeRecordAndClear();
- }
-
- protected:
- class DebugOutput {
- public:
- friend ostream& operator<<(ostream& os, const DebugOutput& debug_output) {
- debug_output.OutputToStream(os);
- return os;
- }
- virtual void OutputToStream(ostream* os) const = 0;
- virtual ~DebugOutput() {}
- };
-
- class FDMaskOutput : public DebugOutput {
- public:
- FDMaskOutput(int fd, int mask, const char* function)
- : fd_(fd), mask_(mask), function_(function) {}
- virtual void OutputToStream(ostream* os) const {
- (*os) << "func: " << function_ << "\tfd: " << fd_;
- if (mask_ != 0) {
- (*os) << "\tmask: " << EventMaskToString(mask_);
- }
- }
- int fd_;
- int mask_;
- const char* function_;
- };
-
- class EpollWaitOutput : public DebugOutput {
- public:
- EpollWaitOutput(int timeout_in_ms, int num_events_generated)
- : timeout_in_ms_(timeout_in_ms),
- num_events_generated_(num_events_generated) {}
- virtual void OutputToStream(ostream* os) const {
- (*os) << "timeout_in_ms: " << timeout_in_ms_
- << "\tnum_events_generated: " << num_events_generated_;
- }
-
- protected:
- int timeout_in_ms_;
- int num_events_generated_;
- };
-
- struct Events {
- Events()
- : epoll_in(0),
- epoll_pri(0),
- epoll_out(0),
- epoll_rdnorm(0),
- epoll_rdband(0),
- epoll_wrnorm(0),
- epoll_wrband(0),
- epoll_msg(0),
- epoll_err(0),
- epoll_hup(0),
- epoll_oneshot(0),
- epoll_et(0) {}
-
- void AssignFromMask(int event_mask) {
- if (event_mask & EPOLLIN) ++epoll_in;
- if (event_mask & EPOLLPRI) ++epoll_pri;
- if (event_mask & EPOLLOUT) ++epoll_out;
- if (event_mask & EPOLLRDNORM) ++epoll_rdnorm;
- if (event_mask & EPOLLRDBAND) ++epoll_rdband;
- if (event_mask & EPOLLWRNORM) ++epoll_wrnorm;
- if (event_mask & EPOLLWRBAND) ++epoll_wrband;
- if (event_mask & EPOLLMSG) ++epoll_msg;
- if (event_mask & EPOLLERR) ++epoll_err;
- if (event_mask & EPOLLHUP) ++epoll_hup;
- if (event_mask & EPOLLONESHOT) ++epoll_oneshot;
- if (event_mask & EPOLLET) ++epoll_et;
- }
-
- friend ostream& operator<<(ostream& os, const Events& ev) {
- if (ev.epoll_in) {
- os << "\t EPOLLIN: " << ev.epoll_in << "\n";
- }
- if (ev.epoll_pri) {
- os << "\t EPOLLPRI: " << ev.epoll_pri << "\n";
- }
- if (ev.epoll_out) {
- os << "\t EPOLLOUT: " << ev.epoll_out << "\n";
- }
- if (ev.epoll_rdnorm) {
- os << "\t EPOLLRDNORM: " << ev.epoll_rdnorm << "\n";
- }
- if (ev.epoll_rdband) {
- os << "\t EPOLLRDBAND: " << ev.epoll_rdband << "\n";
- }
- if (ev.epoll_wrnorm) {
- os << "\t EPOLLWRNORM: " << ev.epoll_wrnorm << "\n";
- }
- if (ev.epoll_wrband) {
- os << "\t EPOLLWRBAND: " << ev.epoll_wrband << "\n";
- }
- if (ev.epoll_msg) {
- os << "\t EPOLLMSG: " << ev.epoll_msg << "\n";
- }
- if (ev.epoll_err) {
- os << "\t EPOLLERR: " << ev.epoll_err << "\n";
- }
- if (ev.epoll_hup) {
- os << "\t EPOLLHUP: " << ev.epoll_hup << "\n";
- }
- if (ev.epoll_oneshot) {
- os << "\t EPOLLONESHOT: " << ev.epoll_oneshot << "\n";
- }
- if (ev.epoll_et) {
- os << "\t EPOLLET: " << ev.epoll_et << "\n";
- }
- return os;
- }
-
- unsigned int epoll_in;
- unsigned int epoll_pri;
- unsigned int epoll_out;
- unsigned int epoll_rdnorm;
- unsigned int epoll_rdband;
- unsigned int epoll_wrnorm;
- unsigned int epoll_wrband;
- unsigned int epoll_msg;
- unsigned int epoll_err;
- unsigned int epoll_hup;
- unsigned int epoll_oneshot;
- unsigned int epoll_et;
- };
-
- std::vector<DebugOutput*> debug_events_;
- std::vector<Events> unregistered_fds_;
- using EventCountsMap = std::unordered_map<int, Events>;
- EventCountsMap event_counts_;
- int64_t num_records_;
- int64_t record_threshold_;
- };
-
- void ClearEventRecords() { event_recorder_.Clear(); }
- void WriteEventRecords(ostream* os) const { (*os) << event_recorder_; }
-
- mutable EventRecorder event_recorder_;
-
-#endif
-
- private:
- // Helper functions used in the destructor.
- void CleanupFDToCBMap();
- void CleanupTimeToAlarmCBMap();
-
- // The callback registered to the fds below. As the purpose of their
- // registration is to wake the epoll server it just clears the pipe and
- // returns.
- std::unique_ptr<ReadPipeCallback> wake_cb_;
-
- // A pipe owned by the epoll server. The server will be registered to listen
- // on read_fd_ and can be woken by Wake() which writes to write_fd_.
- int read_fd_;
- int write_fd_;
-
- // This boolean is checked to see if it is false at the top of the
- // WaitForEventsAndExecuteCallbacks function. If not, then it either returns
- // without doing work, and logs to ERROR, or aborts the program (in
- // DEBUG mode). If so, then it sets the bool to true, does work, and
- // sets it back to false when done. This catches unwanted recursion.
- bool in_wait_for_events_and_execute_callbacks_;
-
- // Returns true when the SimpleEpollServer() is being destroyed.
- bool in_shutdown_;
- int64_t last_delay_in_usec_;
-};
-
-class EpollAlarmCallbackInterface {
- public:
- // Summary:
- // Called when an alarm times out. Invalidates an AlarmRegToken.
- // WARNING: If a token was saved to refer to an alarm callback, OnAlarm must
- // delete it, as the reference is no longer valid.
- // Returns:
- // the unix time (in microseconds) at which this alarm should be signaled
- // again, or 0 if the alarm should be removed.
- virtual int64_t OnAlarm() = 0;
-
- // Summary:
- // Called when the an alarm is registered. Invalidates an AlarmRegToken.
- // Args:
- // token: the iterator to the alarm registered in the alarm map.
- // WARNING: this token becomes invalid when the alarm fires, is
- // unregistered, or OnShutdown is called on that alarm.
- // eps: the epoll server the alarm is registered with.
- virtual void OnRegistration(const SimpleEpollServer::AlarmRegToken& token,
- SimpleEpollServer* eps) = 0;
-
- // Summary:
- // Called when the an alarm is unregistered.
- // WARNING: It is not valid to unregister a callback and then use the token
- // that was saved to refer to the callback.
- virtual void OnUnregistration() = 0;
-
- // Summary:
- // Called when the epoll server is shutting down.
- // Invalidates the AlarmRegToken that was given when this alarm was
- // registered.
- virtual void OnShutdown(SimpleEpollServer* eps) = 0;
-
- virtual ~EpollAlarmCallbackInterface() {}
-
- protected:
- EpollAlarmCallbackInterface() {}
-};
-
-// A simple alarm which unregisters itself on destruction.
-//
-// PLEASE NOTE:
-// Any classes overriding these functions must either call the implementation
-// of the parent class, or is must otherwise make sure that the 'registered_'
-// boolean and the token, 'token_', are updated appropriately.
-class EpollAlarm : public EpollAlarmCallbackInterface {
- public:
- EpollAlarm();
-
- ~EpollAlarm() override;
-
- // Marks the alarm as unregistered and returns 0. The return value may be
- // safely ignored by subclasses.
- int64_t OnAlarm() override;
-
- // Marks the alarm as registered, and stores the token.
- void OnRegistration(const SimpleEpollServer::AlarmRegToken& token,
- SimpleEpollServer* eps) override;
-
- // Marks the alarm as unregistered.
- void OnUnregistration() override;
-
- // Marks the alarm as unregistered.
- void OnShutdown(SimpleEpollServer* eps) override;
-
- // If the alarm was registered, unregister it.
- void UnregisterIfRegistered();
-
- // Reregisters the alarm at specified time.
- void ReregisterAlarm(int64_t timeout_time_in_us);
-
- bool registered() const { return registered_; }
-
- const SimpleEpollServer* eps() const { return eps_; }
-
- private:
- SimpleEpollServer::AlarmRegToken token_;
- SimpleEpollServer* eps_;
- bool registered_;
-};
-
-} // namespace epoll_server
-
-#endif // QUICHE_EPOLL_SERVER_SIMPLE_EPOLL_SERVER_H_
diff --git a/quiche/epoll_server/simple_epoll_server_test.cc b/quiche/epoll_server/simple_epoll_server_test.cc
deleted file mode 100644
index ba85038..0000000
--- a/quiche/epoll_server/simple_epoll_server_test.cc
+++ /dev/null
@@ -1,2494 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Epoll tests which determine that the right things happen in the right order.
-// Also lots of testing of individual functions.
-
-#include "quiche/epoll_server/simple_epoll_server.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <netinet/in.h>
-#include <sys/epoll.h>
-#include <sys/socket.h>
-#include <unistd.h>
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdlib>
-#include <cstring>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "absl/time/clock.h"
-#include "quiche/epoll_server/fake_simple_epoll_server.h"
-#include "quiche/epoll_server/platform/api/epoll_address_test_utils.h"
-#include "quiche/epoll_server/platform/api/epoll_expect_bug.h"
-#include "quiche/epoll_server/platform/api/epoll_test.h"
-#include "quiche/epoll_server/platform/api/epoll_thread.h"
-
-namespace epoll_server {
-
-namespace test {
-
-namespace {
-
-const int kPageSize = 4096;
-const int kMaxBufLen = 10000;
-
-// These are used to record what is happening.
-enum {
- CREATION,
- REGISTRATION,
- MODIFICATION,
- EVENT,
- UNREGISTRATION,
- SHUTDOWN,
- DESTRUCTION
-};
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-int64_t WallTimeNowInUsec() { return absl::GetCurrentTimeNanos() / 1000; }
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-struct RecordEntry {
- RecordEntry() : time(0), instance(nullptr), event_type(0), fd(0), data(0) {}
-
- RecordEntry(int64_t time, void* instance, int event_type, int fd, int data)
- : time(time),
- instance(instance),
- event_type(event_type),
- fd(fd),
- data(data) {}
-
- int64_t time;
- void* instance;
- int event_type;
- int fd;
- int data;
-
- bool IsEqual(const RecordEntry* entry) const {
- bool retval = true;
-
- if (instance != entry->instance) {
- retval = false;
- EPOLL_LOG(INFO) << " instance (" << instance << ") != entry->instance("
- << entry->instance << ")";
- }
- if (event_type != entry->event_type) {
- retval = false;
- EPOLL_LOG(INFO) << " event_type (" << event_type
- << ") != entry->event_type(" << entry->event_type << ")";
- }
- if (fd != entry->fd) {
- retval = false;
- EPOLL_LOG(INFO) << " fd (" << fd << ") != entry->fd (" << entry->fd
- << ")";
- }
- if (data != entry->data) {
- retval = false;
- EPOLL_LOG(INFO) << " data (" << data << ") != entry->data(" << entry->data
- << ")";
- }
- return retval;
- }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-class Recorder {
- public:
- void Record(void* instance, int event_type, int fd, int data) {
- records_.push_back(
- RecordEntry(WallTimeNowInUsec(), instance, event_type, fd, data));
- }
-
- const std::vector<RecordEntry>* records() const { return &records_; }
-
- bool IsEqual(const Recorder* recorder) const {
- const std::vector<RecordEntry>* records = recorder->records();
-
- if (records_.size() != records->size()) {
- EPOLL_LOG(INFO) << "records_.size() (" << records_.size()
- << ") != records->size() (" << records->size() << ")";
- return false;
- }
- for (size_t i = 0; i < std::min(records_.size(), records->size()); ++i) {
- if (!records_[i].IsEqual(&(*records)[i])) {
- EPOLL_LOG(INFO) << "entry in index: " << i << " differs from recorder.";
- return false;
- }
- }
- return true;
- }
-
- private:
- std::vector<RecordEntry> records_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-class RecordingCB : public EpollCallbackInterface {
- public:
- RecordingCB() : recorder_(new Recorder()) {
- recorder_->Record(this, CREATION, 0, 0);
- }
-
- ~RecordingCB() override {
- recorder_->Record(this, DESTRUCTION, 0, 0);
- delete recorder_;
- }
-
- void OnRegistration(SimpleEpollServer* /*eps*/, int fd,
- int event_mask) override {
- recorder_->Record(this, REGISTRATION, fd, event_mask);
- }
-
- void OnModification(int fd, int event_mask) override {
- recorder_->Record(this, MODIFICATION, fd, event_mask);
- }
-
- void OnEvent(int fd, EpollEvent* event) override {
- recorder_->Record(this, EVENT, fd, event->in_events);
- if (event->in_events & EPOLLIN) {
- const int kLength = 1024;
- char buf[kLength];
- int data_read;
- do {
- data_read = read(fd, &buf, kLength);
- } while (data_read > 0);
- }
- }
-
- void OnUnregistration(int fd, bool replaced) override {
- recorder_->Record(this, UNREGISTRATION, fd, replaced);
- }
-
- void OnShutdown(SimpleEpollServer* eps, int fd) override {
- if (fd >= 0) {
- eps->UnregisterFD(fd);
- }
- recorder_->Record(this, SHUTDOWN, fd, 0);
- }
-
- std::string Name() const override { return "RecordingCB"; }
-
- const Recorder* recorder() const { return recorder_; }
-
- protected:
- Recorder* recorder_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-// A simple test server that adds some test functions to SimpleEpollServer as
-// well as allowing access to protected functions.
-class EpollTestServer : public SimpleEpollServer {
- public:
- EpollTestServer() : SimpleEpollServer() {}
-
- ~EpollTestServer() override {}
-
- void CheckMapping(int fd, CB* cb) {
- CBAndEventMask tmp;
- tmp.fd = fd;
- FDToCBMap::iterator fd_i = cb_map_.find(tmp);
- CHECK(fd_i != cb_map_.end()); // Chokes CHECK_NE.
- CHECK(fd_i->cb == cb);
- }
-
- void CheckNotMapped(int fd) {
- CBAndEventMask tmp;
- tmp.fd = fd;
- FDToCBMap::iterator fd_i = cb_map_.find(tmp);
- CHECK(fd_i == cb_map_.end()); // Chokes CHECK_EQ.
- }
-
- void CheckEventMask(int fd, int event_mask) {
- CBAndEventMask tmp;
- tmp.fd = fd;
- FDToCBMap::iterator fd_i = cb_map_.find(tmp);
- CHECK(cb_map_.end() != fd_i); // Chokes CHECK_NE.
- CHECK_EQ(fd_i->event_mask, event_mask);
- }
-
- void CheckNotRegistered(int fd) {
- struct epoll_event ee;
- memset(&ee, 0, sizeof(ee));
- // If the fd is registered, the epoll_ctl call would succeed (return 0) and
- // the CHECK would fail.
- CHECK(epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, &ee));
- }
-
- size_t GetNumPendingAlarmsForTest() const { return alarm_map_.size(); }
-
- bool ContainsAlarm(AlarmCB* ac) {
- return all_alarms_.find(ac) != all_alarms_.end();
- }
-
- using SimpleEpollServer::WaitForEventsAndCallHandleEvents;
-};
-
-class EpollFunctionTest : public EpollTest {
- public:
- EpollFunctionTest()
- : fd_(-1), fd2_(-1), recorder_(nullptr), cb_(nullptr), ep_(nullptr) {}
-
- ~EpollFunctionTest() override {
- delete ep_;
- delete cb_;
- }
-
- void SetUp() override {
- ep_ = new EpollTestServer();
- cb_ = new RecordingCB();
- // recorder_ is safe to use directly as we know it has the same scope as
- // cb_
- recorder_ = cb_->recorder();
-
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
- fd_ = pipe_fds[0];
- fd2_ = pipe_fds[1];
- }
-
- void TearDown() override {
- close(fd_);
- close(fd2_);
- }
-
- void DeleteSimpleEpollServer() {
- delete ep_;
- ep_ = nullptr;
- }
-
- int fd() { return fd_; }
- int fd2() { return fd2_; }
- EpollTestServer* ep() { return ep_; }
- EpollCallbackInterface* cb() { return cb_; }
- const Recorder* recorder() { return recorder_; }
-
- private:
- int fd_;
- int fd2_;
- const Recorder* recorder_;
- RecordingCB* cb_;
- EpollTestServer* ep_;
-};
-
-TEST_F(EpollFunctionTest, TestUnconnectedSocket) {
- int fd = socket(AddressFamilyUnderTest(), SOCK_STREAM, IPPROTO_TCP);
- ep()->RegisterFD(fd, cb(), EPOLLIN | EPOLLOUT);
- ep()->WaitForEventsAndExecuteCallbacks();
-
- Recorder tmp;
- tmp.Record(cb(), CREATION, 0, 0);
- tmp.Record(cb(), REGISTRATION, fd, EPOLLIN | EPOLLOUT);
- tmp.Record(cb(), EVENT, fd, EPOLLOUT | EPOLLHUP);
- EXPECT_TRUE(recorder()->IsEqual(&tmp));
-}
-
-TEST_F(EpollFunctionTest, TestRegisterFD) {
- // Check that the basic register works.
- ep()->RegisterFD(fd(), cb(), EPOLLIN);
-
- // Make sure that the fd-CB mapping is there.
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN);
-
- // Now make sure that if we register again, we stomp the old callback.
- // Also make sure we handle O_NONBLOCK correctly
- RecordingCB cb2;
- ep()->RegisterFD(fd(), &cb2, EPOLLOUT | O_NONBLOCK);
- ep()->CheckMapping(fd(), &cb2);
- ep()->CheckEventMask(fd(), EPOLLOUT | O_NONBLOCK);
-
- // Clean up.
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestRegisterFDForWrite) {
- ep()->RegisterFDForWrite(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLOUT);
-
- // Clean up.
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestRegisterFDForReadWrite) {
- ep()->RegisterFDForReadWrite(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN | EPOLLOUT);
-
- // Clean up.
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestRegisterFDForRead) {
- ep()->RegisterFDForRead(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN);
-
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestUnregisterFD) {
- ep()->RegisterFDForRead(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN);
-
- // Unregister and make sure that it's gone.
- ep()->UnregisterFD(fd());
- ep()->CheckNotMapped(fd());
- ep()->CheckNotRegistered(fd());
-
- // And make sure that unregistering something a second time doesn't cause
- // crashes.
- ep()->UnregisterFD(fd());
- ep()->CheckNotMapped(fd());
- ep()->CheckNotRegistered(fd());
-}
-
-TEST_F(EpollFunctionTest, TestModifyCallback) {
- // Check that nothing terrible happens if we modify an unregistered fd.
- ep()->ModifyCallback(fd(), EPOLLOUT);
- ep()->CheckNotMapped(fd());
- ep()->CheckNotRegistered(fd());
-
- // Check that the basic register works.
- ep()->RegisterFD(fd(), cb(), EPOLLIN);
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN);
-
- // Check that adding a signal swaps it out for the first.
- ep()->ModifyCallback(fd(), EPOLLOUT);
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLOUT);
-
- // Check that modifying from X to X works correctly.
- ep()->ModifyCallback(fd(), EPOLLOUT);
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLOUT);
-
- // Check that modifying from something to nothing works.
- ep()->ModifyCallback(fd(), 0);
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), 0);
-
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestStopRead) {
- ep()->RegisterFDForReadWrite(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN | EPOLLOUT);
-
- // Unregister and make sure you only lose the read event.
- ep()->StopRead(fd());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLOUT);
-
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestStartRead) {
- ep()->RegisterFDForWrite(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLOUT);
-
- // Make sure that StartRead adds EPOLLIN and doesn't remove other signals.
- ep()->StartRead(fd());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN | EPOLLOUT);
-
- // Clean up.
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestStopWrite) {
- ep()->RegisterFDForReadWrite(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN | EPOLLOUT);
-
- // Unregister write and make sure you only lose the write event.
- ep()->StopWrite(fd());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN);
-
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestStartWrite) {
- ep()->RegisterFDForRead(fd(), cb());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN);
-
- // Make sure that StartWrite adds EPOLLOUT and doesn't remove other
- // signals.
- ep()->StartWrite(fd());
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), EPOLLIN | EPOLLOUT);
-
- // Clean up.
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestSet_timeout_in_us) {
- // Check that set works with various values. There's a separate test below
- // to make sure the values are used properly.
- ep()->set_timeout_in_us(10);
- EXPECT_EQ(10, ep()->timeout_in_us_for_test());
-
- ep()->set_timeout_in_us(-1);
- EXPECT_EQ(-1, ep()->timeout_in_us_for_test());
-}
-
-TEST_F(EpollFunctionTest, TestHandleEvent) {
- const std::vector<RecordEntry>* records = recorder()->records();
-
- // Test that nothing bad happens if the FD is not in the map.
- ep()->HandleEvent(fd(), EPOLLOUT);
- ep()->CallReadyListCallbacks();
-
- ep()->RegisterFD(fd(), cb(), 0);
- ep()->CheckMapping(fd(), cb());
- ep()->CheckEventMask(fd(), 0);
-
- // At this point we should have creation and registration recorded.
- EXPECT_EQ(2u, records->size());
-
- // Call handle event and make sure something was recorded.
- ep()->HandleEvent(fd(), EPOLLOUT);
- ep()->CallReadyListCallbacks();
- EXPECT_EQ(3u, records->size());
-
- // Call handle event and make sure something was recorded.
- ep()->HandleEvent(fd(), EPOLLIN | O_NONBLOCK);
- ep()->CallReadyListCallbacks();
- EXPECT_EQ(4u, records->size());
-
- Recorder tmp;
- tmp.Record(cb(), CREATION, 0, 0);
- tmp.Record(cb(), REGISTRATION, fd(), 0);
- tmp.Record(cb(), EVENT, fd(), EPOLLOUT);
- tmp.Record(cb(), EVENT, fd(), EPOLLIN | O_NONBLOCK);
-
- EXPECT_TRUE(recorder()->IsEqual(&tmp));
- ep()->UnregisterFD(fd());
-}
-
-TEST_F(EpollFunctionTest, TestNumFDsRegistered) {
- EXPECT_EQ(0, ep()->NumFDsRegistered());
-
- ep()->RegisterFD(fd(), cb(), 0);
- EXPECT_EQ(1, ep()->NumFDsRegistered());
-
- ep()->RegisterFD(fd2(), cb(), 0);
- EXPECT_EQ(2, ep()->NumFDsRegistered());
-
- ep()->RegisterFD(fd2(), cb(), 0);
- EXPECT_EQ(2, ep()->NumFDsRegistered());
-
- ep()->UnregisterFD(fd2());
- EXPECT_EQ(1, ep()->NumFDsRegistered());
-
- ep()->UnregisterFD(fd());
- EXPECT_EQ(0, ep()->NumFDsRegistered());
-}
-
-// Check all of the individual signals and 1-2 combinations.
-TEST_F(EpollFunctionTest, TestEventMaskToString) {
- std::string test;
-
- test = SimpleEpollServer::EventMaskToString(EPOLLIN);
- EXPECT_EQ(test, "EPOLLIN ");
-
- test = SimpleEpollServer::EventMaskToString(EPOLLOUT);
- EXPECT_EQ(test, "EPOLLOUT ");
-
- test = SimpleEpollServer::EventMaskToString(EPOLLPRI);
- EXPECT_EQ(test, "EPOLLPRI ");
-
- test = SimpleEpollServer::EventMaskToString(EPOLLERR);
- EXPECT_EQ(test, "EPOLLERR ");
-
- test = SimpleEpollServer::EventMaskToString(EPOLLHUP);
- EXPECT_EQ(test, "EPOLLHUP ");
-
- test = SimpleEpollServer::EventMaskToString(EPOLLHUP | EPOLLIN);
- EXPECT_EQ(test, "EPOLLIN EPOLLHUP ");
-
- test = SimpleEpollServer::EventMaskToString(EPOLLIN | EPOLLOUT);
- EXPECT_EQ(test, "EPOLLIN EPOLLOUT ");
-}
-
-class TestAlarm : public EpollAlarmCallbackInterface {
- public:
- TestAlarm()
- : time_before_next_alarm_(-1),
- was_called_(false),
- num_called_(0),
- absolute_time_(false),
- onshutdown_called_(false),
- has_token_(false),
- eps_(nullptr) {}
- ~TestAlarm() override {}
- int64_t OnAlarm() override {
- has_token_ = false;
- was_called_ = true;
- ++num_called_;
- if (time_before_next_alarm_ < 0) {
- return 0;
- }
- if (absolute_time_) {
- return time_before_next_alarm_;
- } else {
- return WallTimeNowInUsec() + time_before_next_alarm_;
- }
- }
-
- void OnShutdown(SimpleEpollServer* /*eps*/) override {
- onshutdown_called_ = true;
- has_token_ = false;
- }
- void OnRegistration(const SimpleEpollServer::AlarmRegToken& token,
- SimpleEpollServer* eps) override {
- has_token_ = true;
- last_token_ = token;
- eps_ = eps;
- }
- void OnUnregistration() override { has_token_ = false; }
-
- void UnregisterIfRegistered(SimpleEpollServer* eps) {
- if (has_token_) {
- eps->UnregisterAlarm(last_token_);
- }
- }
-
- void ReregisterAlarm(int64_t timeout_in_us) {
- CHECK(has_token_);
- eps_->ReregisterAlarm(last_token_, timeout_in_us);
- }
-
- void Reset() {
- time_before_next_alarm_ = -1;
- was_called_ = false;
- absolute_time_ = false;
- }
-
- bool was_called() const { return was_called_; }
- int num_called() const { return num_called_; }
-
- void set_time_before_next_alarm(int64_t time) {
- time_before_next_alarm_ = time;
- }
- void set_absolute_time(bool absolute) { absolute_time_ = absolute; }
- bool onshutdown_called() { return onshutdown_called_; }
-
- protected:
- int64_t time_before_next_alarm_;
- bool was_called_;
- int num_called_;
- // Is time_before_next_alarm relative to the current time or absolute?
- bool absolute_time_;
- bool onshutdown_called_;
- bool has_token_;
- SimpleEpollServer::AlarmRegToken last_token_;
- SimpleEpollServer* eps_;
-};
-
-class TestChildAlarm;
-
-// This node unregister all other alarms when it receives
-// OnShutdown() from any one child.
-class TestParentAlarm {
- public:
- void OnShutdown(TestChildAlarm* child, SimpleEpollServer* eps) {
- // Unregister
- for (ChildTokenMap::const_iterator it = child_tokens_.begin();
- it != child_tokens_.end(); ++it) {
- if (it->first != child) {
- eps->UnregisterAlarm(it->second);
- }
- }
- child_tokens_.clear();
- }
-
- void OnRegistration(TestChildAlarm* child,
- const SimpleEpollServer::AlarmRegToken& token) {
- child_tokens_[child] = token;
- }
-
- protected:
- typedef std::unordered_map<TestChildAlarm*, SimpleEpollServer::AlarmRegToken>
- ChildTokenMap;
-
- ChildTokenMap child_tokens_;
-};
-
-class TestChildAlarm : public TestAlarm {
- public:
- void set_parent(TestParentAlarm* tp) { parent_ = tp; }
- void OnShutdown(SimpleEpollServer* eps) override {
- onshutdown_called_ = true;
- // Inform parent of shutdown
- parent_->OnShutdown(this, eps);
- }
- void OnRegistration(const SimpleEpollServer::AlarmRegToken& token,
- SimpleEpollServer* /*eps*/) override {
- parent_->OnRegistration(this, token);
- }
-
- protected:
- TestParentAlarm* parent_;
-};
-
-class TestAlarmThatRegistersAnotherAlarm : public TestAlarm {
- public:
- TestAlarmThatRegistersAnotherAlarm()
- : alarm_(nullptr),
- reg_time_delta_usec_(0),
- eps_to_register_(nullptr),
- has_reg_alarm_(false) {}
- void SetRegisterAlarm(TestAlarm* alarm, int64_t time_delta_usec,
- SimpleEpollServer* eps) {
- alarm_ = alarm;
- reg_time_delta_usec_ = time_delta_usec;
- has_reg_alarm_ = true;
- eps_to_register_ = eps;
- }
- int64_t OnAlarm() override {
- if (has_reg_alarm_) {
- eps_to_register_->RegisterAlarm(
- eps_to_register_->ApproximateNowInUsec() + reg_time_delta_usec_,
- alarm_);
- has_reg_alarm_ = false;
- }
- return TestAlarm::OnAlarm();
- }
-
- protected:
- TestAlarm* alarm_;
- int64_t reg_time_delta_usec_;
- SimpleEpollServer* eps_to_register_;
- bool has_reg_alarm_;
-};
-
-class TestAlarmThatRegistersAndReregistersAnotherAlarm : public TestAlarm {
- public:
- TestAlarmThatRegistersAndReregistersAnotherAlarm()
- : alarm_(nullptr),
- reg_time_delta_usec_(0),
- reregister_time_delta_usec_(0),
- eps_to_register_(nullptr),
- has_reg_alarm_(false) {}
- void SetRegisterAndReregisterAlarm(TestAlarm* alarm, int64_t time_delta_usec,
- int64_t reregister_delta_usec,
- SimpleEpollServer* eps) {
- alarm_ = alarm;
- reg_time_delta_usec_ = time_delta_usec;
- reregister_time_delta_usec_ = reregister_delta_usec;
- has_reg_alarm_ = true;
- eps_to_register_ = eps;
- }
- int64_t OnAlarm() override {
- if (has_reg_alarm_) {
- eps_to_register_->RegisterAlarm(
- eps_to_register_->ApproximateNowInUsec() + reg_time_delta_usec_,
- alarm_);
- alarm_->ReregisterAlarm(eps_to_register_->ApproximateNowInUsec() +
- reregister_time_delta_usec_);
- has_reg_alarm_ = false;
- }
- return TestAlarm::OnAlarm();
- }
-
- protected:
- TestAlarm* alarm_;
- int64_t reg_time_delta_usec_;
- int64_t reregister_time_delta_usec_;
- SimpleEpollServer* eps_to_register_;
- bool has_reg_alarm_;
-};
-
-class TestAlarmThatUnregistersAnotherAlarm : public TestAlarm {
- public:
- TestAlarmThatUnregistersAnotherAlarm()
- : alarm_(nullptr), eps_to_register_(nullptr), has_unreg_alarm_(false) {}
- void SetUnregisterAlarm(TestAlarm* alarm, SimpleEpollServer* eps) {
- alarm_ = alarm;
- has_unreg_alarm_ = true;
- eps_to_register_ = eps;
- }
- int64_t OnAlarm() override {
- if (has_unreg_alarm_) {
- has_unreg_alarm_ = false;
- alarm_->UnregisterIfRegistered(eps_to_register_);
- }
- return TestAlarm::OnAlarm();
- }
-
- protected:
- TestAlarm* alarm_;
- SimpleEpollServer* eps_to_register_;
- bool has_unreg_alarm_;
-};
-
-class TestAlarmUnregister : public TestAlarm {
- public:
- TestAlarmUnregister()
- : onunregistration_called_(false), iterator_token_(nullptr) {}
- ~TestAlarmUnregister() override { delete iterator_token_; }
-
- void OnShutdown(SimpleEpollServer* /*eps*/) override {
- onshutdown_called_ = true;
- }
-
- int64_t OnAlarm() override {
- delete iterator_token_;
- iterator_token_ = nullptr;
-
- return TestAlarm::OnAlarm();
- }
-
- void OnRegistration(const SimpleEpollServer::AlarmRegToken& token,
- SimpleEpollServer* /*eps*/) override {
- // Multiple iterator tokens are not maintained by this code,
- // so we should have reset the iterator_token in OnAlarm or
- // OnUnregistration.
- CHECK(iterator_token_ == nullptr);
- iterator_token_ = new SimpleEpollServer::AlarmRegToken(token);
- }
- void OnUnregistration() override {
- delete iterator_token_;
- iterator_token_ = nullptr;
- // Make sure that this alarm was not already unregistered.
- CHECK(onunregistration_called_ == false);
- onunregistration_called_ = true;
- }
-
- bool onunregistration_called() { return onunregistration_called_; }
- // Returns true if the token has been filled in with the saved iterator
- // and false if it has not.
- bool get_token(SimpleEpollServer::AlarmRegToken* token) {
- if (iterator_token_ != nullptr) {
- *token = *iterator_token_;
- return true;
- } else {
- return false;
- }
- }
-
- protected:
- bool onunregistration_called_;
- SimpleEpollServer::AlarmRegToken* iterator_token_;
-};
-
-void WaitForAlarm(SimpleEpollServer* eps, const TestAlarm& alarm) {
- for (int i = 0; i < 5; ++i) {
- // Ideally we would only have to call this once but it could wake up a bit
- // early and so not call the alarm. If it wakes up early several times
- // there is something wrong.
- eps->WaitForEventsAndExecuteCallbacks();
- if (alarm.was_called()) {
- break;
- }
- }
-}
-
-// Check a couple of alarm times to make sure they're falling within a
-// reasonable range.
-TEST(SimpleEpollServerTest, TestAlarms) {
- EpollTestServer ep;
- TestAlarm alarm;
-
- int alarm_time = 10;
-
- // Register an alarm and make sure we wait long enough to hit it.
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- ep.RegisterAlarm(WallTimeNowInUsec() + alarm_time, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- WaitForAlarm(&ep, alarm);
- EXPECT_TRUE(alarm.was_called());
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- alarm.Reset();
-
- // Test a different time just to be careful.
- alarm_time = 20;
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- ep.RegisterAlarm(WallTimeNowInUsec() + alarm_time, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- WaitForAlarm(&ep, alarm);
- EXPECT_TRUE(alarm.was_called());
- alarm.Reset();
-
- // The alarm was a one-time thing. Make sure that we don't hit it again.
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_FALSE(alarm.was_called());
- alarm.Reset();
-}
-
-// Same as above, but using RegisterAlarmApproximateDelta.
-TEST(SimpleEpollServerTest, TestRegisterAlarmApproximateDelta) {
- EpollTestServer ep;
- TestAlarm alarm;
-
- int alarm_time = 10;
-
- // Register an alarm and make sure we wait long enough to hit it.
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- ep.RegisterAlarmApproximateDelta(alarm_time * 1000, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- WaitForAlarm(&ep, alarm);
- EXPECT_TRUE(alarm.was_called());
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- alarm.Reset();
- int64_t first_now = ep.ApproximateNowInUsec();
- EXPECT_LT(0u, first_now);
-
- // Test a different time just to be careful.
- alarm_time = 20;
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- ep.RegisterAlarmApproximateDelta(alarm_time * 1000, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- WaitForAlarm(&ep, alarm);
- EXPECT_TRUE(alarm.was_called());
- alarm.Reset();
- int64_t second_now = ep.ApproximateNowInUsec();
-
- EXPECT_LT(first_now, second_now);
-
- // The alarm was a one-time thing. Make sure that we don't hit it again.
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_FALSE(alarm.was_called());
- alarm.Reset();
-}
-
-TEST(SimpleEpollServerTest, TestAlarmsWithInfiniteWait) {
- EpollTestServer ep;
- TestAlarm alarm;
-
- int alarm_time = 10;
-
- // Register an alarm and make sure we wait long enough to hit it.
- ep.set_timeout_in_us(-1);
- ep.RegisterAlarm(WallTimeNowInUsec() + alarm_time, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- WaitForAlarm(&ep, alarm);
- EXPECT_TRUE(alarm.was_called());
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- alarm.Reset();
-}
-
-// In this test we have an alarm that when fires gets re-registered
-// at almost the same time at which it fires. Here, we want to make
-// sure that when the alarm gets re-registered we do not call OnAlarm()
-// on the same Alarm object again, until we have called
-// WaitForEventsAndExecuteCallbacks(). A poor implementation of epoll
-// server alarm handling can potentially cause OnAlarm() to be called
-// multiple times. We make sure that the epoll server is not going in
-// an infinite loop by checking that OnAlarm() is called exactly once
-// on the alarm object that got registered again.
-TEST(SimpleEpollServerTest, TestAlarmsThatGetReRegisteredAreNotCalledTwice) {
- // This alarm would get registered again
- TestAlarm alarm;
- TestAlarm alarm2;
- EpollTestServer ep;
- ep.set_timeout_in_us(-1);
-
- int64_t alarm_time = 10;
- int64_t abs_time = WallTimeNowInUsec() + alarm_time * 1000;
-
- // This will make the alarm re-register when OnAlarm is called.
- alarm.set_absolute_time(true);
- alarm.set_time_before_next_alarm(abs_time + 2);
-
- // Register two alarms and make sure we wait long enough to hit it.
- ep.RegisterAlarm(abs_time, &alarm);
- ep.RegisterAlarm(abs_time, &alarm2);
- EXPECT_EQ(2u, ep.GetNumPendingAlarmsForTest());
-
- WaitForAlarm(&ep, alarm);
-
- EXPECT_TRUE(alarm.was_called());
- // Make sure that alarm is called only once.
- EXPECT_EQ(1, alarm.num_called());
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- alarm.Reset();
-}
-
-// Here we make sure that when one alarm unregisters another alarm
-// (that is supposed to be registered again because its OnAlarm
-// returned > 0), the alarm thats supposed to be unregistered does
-// actually gets unregistered.
-TEST(SimpleEpollServerTest, TestAlarmsOneOnAlarmUnRegistersAnotherAlarm) {
- TestAlarm alarm;
- TestAlarmThatUnregistersAnotherAlarm alarm2;
- EpollTestServer ep;
- ep.set_timeout_in_us(-1);
-
- int64_t alarm_time = 1;
- int64_t abs_time = WallTimeNowInUsec() + alarm_time * 1000;
-
- // This will make the alarm re-register when OnAlarm is called.
- alarm.set_absolute_time(true);
- alarm.set_time_before_next_alarm(abs_time + 2);
-
- // Register two alarms and make sure we wait long enough to hit it.
- ep.RegisterAlarm(abs_time, &alarm);
- // This would cause us to unregister alarm when OnAlarm is called
- // on alarm2.
- alarm2.SetUnregisterAlarm(&alarm, &ep);
- ep.RegisterAlarm(abs_time + 1, &alarm2);
- EXPECT_EQ(2u, ep.GetNumPendingAlarmsForTest());
-
- WaitForAlarm(&ep, alarm);
-
- EXPECT_TRUE(alarm.was_called());
- // Make sure that alarm is called only once.
- EXPECT_EQ(1, alarm.num_called());
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- alarm.Reset();
-}
-
-// Check a couple of alarm times to make sure they're falling within a
-// reasonable range.
-TEST(SimpleEpollServerTest, TestRepeatAlarms) {
- EpollTestServer ep;
- TestAlarm alarm;
-
- int alarm_time = 20;
-
- // Register an alarm and make sure we wait long enough to hit it.
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- alarm.set_time_before_next_alarm(1000 * alarm_time);
- ep.RegisterAlarm(WallTimeNowInUsec() + alarm_time, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
-
- WaitForAlarm(&ep, alarm);
- // When we wake up it should be because the Alarm has been called, and has
- // registered itself to be called again.
-
- // Make sure the first alarm was called properly.
- EXPECT_TRUE(alarm.was_called());
-
- // Resetting means that the alarm is no longer a recurring alarm. It will be
- // called once more and then stop.
- alarm.Reset();
-
- // Make sure the alarm is called one final time.
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- WaitForAlarm(&ep, alarm);
-
- EXPECT_TRUE(alarm.was_called());
- alarm.Reset();
-
- // The alarm was a one-time thing. Make sure that we don't hit it again.
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_FALSE(alarm.was_called());
-}
-
-// Verify that an alarm that repeats itself in the past works properly.
-TEST(SimpleEpollServerTest, TestRepeatAlarmInPast) {
- EpollTestServer ep;
- TestAlarm alarm;
-
- int64_t alarm_time = 20;
- int64_t abs_time = WallTimeNowInUsec() + alarm_time * 1000;
-
- // Make the alarm re-register in the past when OnAlarm is called.
- alarm.set_absolute_time(true);
- alarm.set_time_before_next_alarm(abs_time - 1000);
-
- // Register the alarm and make sure we wait long enough to hit it.
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- ep.RegisterAlarm(abs_time, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
-
- WaitForAlarm(&ep, alarm);
- // When we wake up it should be because the Alarm has been called, and has
- // registered itself to be called again.
-
- // Make sure the first alarm was called properly.
- EXPECT_TRUE(alarm.was_called());
-
- // Resetting means that the alarm is no longer a recurring alarm. It will be
- // called once more and then stop.
- alarm.Reset();
-
- // Make sure the alarm is called one final time.
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- ep.set_timeout_in_us(alarm_time * 1000 * 2);
- WaitForAlarm(&ep, alarm);
-
- EXPECT_TRUE(alarm.was_called());
- alarm.Reset();
-
- // The alarm was a one-time thing. Make sure that we don't hit it again.
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_FALSE(alarm.was_called());
-}
-
-class EpollTestAlarms : public SimpleEpollServer {
- public:
- EpollTestAlarms() : SimpleEpollServer() {}
-
- inline int64_t NowInUsec() const override { return time_; }
-
- void CallAndReregisterAlarmEvents() override {
- recorded_now_in_us_ = NowInUsec();
- SimpleEpollServer::CallAndReregisterAlarmEvents();
- }
-
- void set_time(int64_t time) { time_ = time; }
-
- size_t GetNumPendingAlarmsForTest() const { return alarm_map_.size(); }
-
- private:
- int64_t time_;
-};
-
-// Test multiple interleaving alarms to make sure they work right.
-// Pattern is roughly:
-// time: 15 20 30 40
-// alarm: A B A' C
-TEST(SimpleEpollServerTest, TestMultipleAlarms) {
- EpollTestAlarms ep;
- TestAlarm alarmA;
- TestAlarm alarmB;
- TestAlarm alarmC;
-
- ep.set_timeout_in_us(50 * 1000 * 2);
- alarmA.set_time_before_next_alarm(1000 * 30);
- alarmA.set_absolute_time(true);
- ep.RegisterAlarm(15 * 1000, &alarmA);
- ep.RegisterAlarm(20 * 1000, &alarmB);
- ep.RegisterAlarm(40 * 1000, &alarmC);
-
- ep.set_time(15 * 1000);
- ep.CallAndReregisterAlarmEvents(); // A
- EXPECT_TRUE(alarmA.was_called());
- EXPECT_FALSE(alarmB.was_called());
- EXPECT_FALSE(alarmC.was_called());
- alarmA.Reset(); // Unregister A in the future.
-
- ep.set_time(20 * 1000);
- ep.CallAndReregisterAlarmEvents(); // B
- EXPECT_FALSE(alarmA.was_called());
- EXPECT_TRUE(alarmB.was_called());
- EXPECT_FALSE(alarmC.was_called());
- alarmB.Reset();
-
- ep.set_time(30 * 1000);
- ep.CallAndReregisterAlarmEvents(); // A
- EXPECT_TRUE(alarmA.was_called());
- EXPECT_FALSE(alarmB.was_called());
- EXPECT_FALSE(alarmC.was_called());
- alarmA.Reset();
-
- ep.set_time(40 * 1000);
- ep.CallAndReregisterAlarmEvents(); // C
- EXPECT_FALSE(alarmA.was_called());
- EXPECT_FALSE(alarmB.was_called());
- EXPECT_TRUE(alarmC.was_called());
- alarmC.Reset();
-
- ep.CallAndReregisterAlarmEvents(); // None.
- EXPECT_FALSE(alarmA.was_called());
- EXPECT_FALSE(alarmB.was_called());
- EXPECT_FALSE(alarmC.was_called());
-}
-
-TEST(SimpleEpollServerTest, TestAlarmOnShutdown) {
- TestAlarm alarm1;
- {
- EpollTestServer ep;
- const int64_t now = WallTimeNowInUsec();
- ep.RegisterAlarm(now + 5000, &alarm1);
- }
-
- EXPECT_TRUE(alarm1.onshutdown_called());
-}
-
-// Tests that if we have multiple alarms
-// OnShutdown then we handle them properly.
-TEST(SimpleEpollServerTest, TestMultipleAlarmOnShutdown) {
- TestAlarm alarm1;
- TestAlarm alarm2;
- TestAlarm alarm3;
- {
- EpollTestServer ep;
- const int64_t now = WallTimeNowInUsec();
- ep.RegisterAlarm(now + 5000, &alarm1);
- ep.RegisterAlarm(now + 9000, &alarm2);
- ep.RegisterAlarm(now + 9000, &alarm3);
- }
-
- EXPECT_TRUE(alarm1.onshutdown_called());
- EXPECT_TRUE(alarm2.onshutdown_called());
- EXPECT_TRUE(alarm3.onshutdown_called());
-}
-TEST(SimpleEpollServerTest, TestMultipleAlarmUnregistrationOnShutdown) {
- TestParentAlarm tp;
- TestChildAlarm alarm1;
- TestChildAlarm alarm2;
- alarm1.set_parent(&tp);
- alarm2.set_parent(&tp);
- {
- EpollTestServer ep;
- const int64_t now = WallTimeNowInUsec();
- ep.RegisterAlarm(now + 5000, &alarm1);
- ep.RegisterAlarm(now + 9000, &alarm2);
- }
-
- EXPECT_TRUE(alarm1.onshutdown_called());
- EXPECT_FALSE(alarm2.onshutdown_called());
-}
-
-// Check an alarm set in the past runs right away.
-TEST(SimpleEpollServerTest, TestPastAlarm) {
- EpollTestServer ep;
- TestAlarm alarm;
-
- // Register the alarm and make sure we wait long enough to hit it.
- ep.set_timeout_in_us(1000 * 2);
- ep.RegisterAlarm(WallTimeNowInUsec() - 1000, &alarm);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_TRUE(alarm.was_called());
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- alarm.Reset();
-}
-
-// Test Unregistering of Alarms
-TEST(SimpleEpollServerTest, TestUnregisterAlarm) {
- EpollTestServer ep;
- SimpleEpollServer::AlarmRegToken temptok;
-
- TestAlarmUnregister alarm1;
- TestAlarmUnregister alarm2;
-
- ep.RegisterAlarm(WallTimeNowInUsec() + 5 * 1000, &alarm1);
- ep.RegisterAlarm(WallTimeNowInUsec() + 13 * 1000, &alarm2);
-
- // Unregister an alarm.
- if (alarm2.get_token(&temptok)) {
- ep.UnregisterAlarm(temptok);
- }
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- EXPECT_TRUE(alarm2.onunregistration_called());
-
- if (alarm1.get_token(&temptok)) {
- ep.UnregisterAlarm(temptok);
- }
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
- EXPECT_TRUE(alarm1.onunregistration_called());
-}
-
-// Test Reregistering of Alarms
-TEST(SimpleEpollServerTest, TestReregisterAlarm) {
- EpollTestAlarms ep;
- SimpleEpollServer::AlarmRegToken token;
-
- TestAlarmUnregister alarm;
- ep.set_time(1000);
- ep.RegisterAlarm(5000, &alarm);
-
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- ASSERT_TRUE(alarm.get_token(&token));
- ep.ReregisterAlarm(token, 6000);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
-
- ep.set_time(5000);
- ep.set_timeout_in_us(0);
- ep.CallAndReregisterAlarmEvents();
- EXPECT_FALSE(alarm.was_called());
-
- ep.set_time(6000);
- ep.CallAndReregisterAlarmEvents();
- EXPECT_TRUE(alarm.was_called());
-}
-
-TEST(SimpleEpollServerTest, TestReregisterDeferredAlarm) {
- EpollTestAlarms ep;
- ep.set_timeout_in_us(0);
-
- TestAlarm alarm;
- TestAlarmThatRegistersAndReregistersAnotherAlarm register_alarm;
- // Register the alarm in the past so it is added as a deferred alarm.
- register_alarm.SetRegisterAndReregisterAlarm(&alarm, -500, 500, &ep);
- ep.set_time(1000);
- ep.RegisterAlarm(1000, ®ister_alarm);
- // Call reregister twice, first to run register_alarm and second to run any
- // scheduled deferred alarms.
- ep.CallAndReregisterAlarmEvents();
- ep.CallAndReregisterAlarmEvents();
-
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- EXPECT_FALSE(alarm.was_called());
-
- ep.set_time(1500);
- ep.CallAndReregisterAlarmEvents();
- EXPECT_TRUE(alarm.was_called());
-}
-
-// Check if an alarm fired and got reregistered, you are able to
-// unregister the second registration.
-TEST(SimpleEpollServerTest, TestFiredReregisteredAlarm) {
- EpollTestAlarms ep;
- TestAlarmUnregister alarmA;
-
- SimpleEpollServer::AlarmRegToken first_token;
- SimpleEpollServer::AlarmRegToken second_token;
- bool found;
-
- ep.set_timeout_in_us(50 * 1000 * 2);
- alarmA.set_time_before_next_alarm(1000 * 30);
- alarmA.set_absolute_time(true);
-
- // Alarm A first fires at 15, then 30
- ep.RegisterAlarm(15 * 1000, &alarmA);
-
- found = alarmA.get_token(&first_token);
- EXPECT_TRUE(found);
-
- ep.set_time(15 * 1000);
- ep.CallAndReregisterAlarmEvents(); // A
- EXPECT_TRUE(alarmA.was_called());
-
- alarmA.Reset();
-
- found = alarmA.get_token(&second_token);
- EXPECT_TRUE(found);
- if (found) {
- ep.UnregisterAlarm(second_token);
- }
-
- ep.set_time(30 * 1000);
- ep.CallAndReregisterAlarmEvents(); // A
-
- alarmA.Reset();
-}
-
-// Here we make sure that one alarm can unregister another alarm
-// in OnShutdown().
-TEST(SimpleEpollServerTest, TestAlarmCanUnregistersAnotherAlarmOnShutdown) {
- TestAlarmThatUnregistersAnotherAlarm alarm1;
- TestAlarm alarm2;
- {
- EpollTestServer ep;
- // Register two alarms and make alarm1 is placed in queue in front of alarm2
- // so that when the queue is cleared, alarm1 is processed first.
- const int64_t now = WallTimeNowInUsec();
- ep.RegisterAlarm(now + 5000, &alarm1);
- ep.RegisterAlarm(now + 9000, &alarm2);
- alarm1.SetUnregisterAlarm(&alarm2, &ep);
- EXPECT_EQ(2u, ep.GetNumPendingAlarmsForTest());
- }
-}
-
-class TestAlarmRegisterAnotherAlarmShutdown : public TestAlarmUnregister {
- public:
- TestAlarmRegisterAnotherAlarmShutdown(EpollAlarmCallbackInterface* alarm2,
- int64_t when)
- : alarm2_(alarm2), when_(when) {}
- void OnShutdown(SimpleEpollServer* eps) override {
- TestAlarmUnregister::OnShutdown(eps);
- eps->RegisterAlarm(when_, alarm2_);
- }
-
- private:
- EpollAlarmCallbackInterface* alarm2_;
- int64_t when_;
-};
-
-// This tests that alarm registers another alarm when shutting down.
-// The two cases are: new alarm comes before and after the alarm being
-// notified by OnShutdown()
-TEST(SimpleEpollServerTest, AlarmRegistersAnotherAlarmOnShutdownBeforeSelf) {
- TestAlarm alarm2;
- int64_t alarm_time = WallTimeNowInUsec() + 5000;
- TestAlarmRegisterAnotherAlarmShutdown alarm1(&alarm2, alarm_time - 1000);
- {
- EpollTestAlarms ep;
- ep.RegisterAlarm(alarm_time, &alarm1);
- }
- EXPECT_TRUE(alarm1.onshutdown_called());
- EXPECT_FALSE(alarm2.onshutdown_called());
-}
-
-TEST(SimpleEpollServerTest, AlarmRegistersAnotherAlarmOnShutdownAfterSelf) {
- TestAlarm alarm2;
- int64_t alarm_time = WallTimeNowInUsec() + 5000;
- TestAlarmRegisterAnotherAlarmShutdown alarm1(&alarm2, alarm_time + 1000);
- {
- EpollTestAlarms ep;
- ep.RegisterAlarm(alarm_time, &alarm1);
- }
- EXPECT_TRUE(alarm1.onshutdown_called());
- EXPECT_TRUE(alarm2.onshutdown_called());
-}
-
-TEST(SimpleEpollServerTest, TestWrite) {
- SimpleEpollServer ep;
- ep.set_timeout_in_us(1);
- char data[kPageSize] = {0};
-
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
- int read_fd = pipe_fds[0];
- int write_fd = pipe_fds[1];
-
- RecordingCB recording_cb;
- const Recorder* recorder = recording_cb.recorder();
- const std::vector<RecordEntry>* records = recorder->records();
-
- // Register to listen to write events.
- ep.RegisterFD(write_fd, &recording_cb, EPOLLOUT | O_NONBLOCK);
- // At this point the recorder should have the creation and registration
- // events.
- EXPECT_EQ(2u, records->size());
-
- // Fill up the pipe.
- int written = 1;
- for (int i = 0; i < 17 && written > 0; ++i) {
- written = write(write_fd, &data, kPageSize);
- }
- EXPECT_LT(written, 0);
-
- // There should be no new events as the pipe is not available for writing.
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(2u, records->size());
-
- // Now read data from the pipe to make it writable again. This time the
- // we should get an EPOLLOUT event.
- int size = read(read_fd, &data, kPageSize);
- EXPECT_EQ(kPageSize, size);
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(3u, records->size());
-
- // Now unsubscribe from writable events (which adds a modification record)
- // and wait to verify that no event records are added.
- ep.StopWrite(write_fd);
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(4u, records->size());
-
- // We had the right number of events all along. Make sure they were actually
- // the right events.
- Recorder tmp;
- tmp.Record(&recording_cb, CREATION, 0, 0);
- tmp.Record(&recording_cb, REGISTRATION, write_fd, EPOLLOUT | O_NONBLOCK);
- tmp.Record(&recording_cb, EVENT, write_fd, EPOLLOUT);
- tmp.Record(&recording_cb, MODIFICATION, write_fd, O_NONBLOCK);
-
- EXPECT_TRUE(recorder->IsEqual(&tmp));
- ep.UnregisterFD(write_fd);
-
- close(read_fd);
- close(write_fd);
-}
-
-TEST(SimpleEpollServerTest, TestReadWrite) {
- SimpleEpollServer ep;
- ep.set_timeout_in_us(1);
- char data[kPageSize] = {0};
-
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
- int read_fd = pipe_fds[0];
- int write_fd = pipe_fds[1];
-
- RecordingCB recording_cb;
- const Recorder* recorder = recording_cb.recorder();
- const std::vector<RecordEntry>* records = recorder->records();
-
- // Register to listen to read and write events.
- ep.RegisterFDForReadWrite(read_fd, &recording_cb);
- // At this point the recorder should have the creation and registration
- // events.
- EXPECT_EQ(2u, records->size());
-
- int written = write(write_fd, &data, kPageSize);
- EXPECT_EQ(kPageSize, written);
-
- ep.WaitForEventsAndExecuteCallbacks();
- ep.UnregisterFD(read_fd);
-
- close(read_fd);
- close(write_fd);
-}
-
-TEST(SimpleEpollServerTest, TestMultipleFDs) {
- SimpleEpollServer ep;
- ep.set_timeout_in_us(1);
- char data = 'x';
-
- int pipe_one[2];
- if (pipe(pipe_one) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
- int pipe_two[2];
- if (pipe(pipe_two) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
-
- RecordingCB recording_cb_one;
- const Recorder* recorder_one = recording_cb_one.recorder();
- const std::vector<RecordEntry>* records_one = recorder_one->records();
-
- RecordingCB recording_cb_two;
- const Recorder* recorder_two = recording_cb_two.recorder();
- const std::vector<RecordEntry>* records_two = recorder_two->records();
-
- // Register to listen to read events for both pipes
- ep.RegisterFDForRead(pipe_one[0], &recording_cb_one);
- ep.RegisterFDForRead(pipe_two[0], &recording_cb_two);
-
- EXPECT_EQ(2u, records_one->size());
- EXPECT_EQ(2u, records_two->size());
-
- EXPECT_EQ(1, write(pipe_one[1], &data, 1));
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(3u, records_one->size());
- EXPECT_EQ(2u, records_two->size());
-
- EXPECT_EQ(1, write(pipe_two[1], &data, 1));
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(3u, records_one->size());
- EXPECT_EQ(3u, records_two->size());
-
- EXPECT_EQ(1, write(pipe_one[1], &data, 1));
- EXPECT_EQ(1, write(pipe_two[1], &data, 1));
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(4u, records_one->size());
- EXPECT_EQ(4u, records_two->size());
-
- ep.WaitForEventsAndExecuteCallbacks();
- ep.UnregisterFD(pipe_one[0]);
- ep.UnregisterFD(pipe_two[0]);
- close(pipe_one[0]);
- close(pipe_one[1]);
- close(pipe_two[0]);
- close(pipe_two[1]);
-}
-
-// Check that the SimpleEpollServer calls OnShutdown for any registered FDs.
-TEST(SimpleEpollServerTest, TestFDOnShutdown) {
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
- int read_fd = pipe_fds[0];
- int write_fd = pipe_fds[1];
-
- RecordingCB recording_cb1;
- RecordingCB recording_cb2;
- const Recorder* recorder1 = recording_cb1.recorder();
- const Recorder* recorder2 = recording_cb2.recorder();
-
- {
- SimpleEpollServer ep;
- ep.set_timeout_in_us(1);
-
- // Register to listen to write events.
- ep.RegisterFD(write_fd, &recording_cb1, EPOLLOUT | O_NONBLOCK);
- ep.RegisterFD(read_fd, &recording_cb2, EPOLLIN | O_NONBLOCK);
- }
-
- // Make sure OnShutdown was called for both callbacks.
- Recorder write_recorder;
- write_recorder.Record(&recording_cb1, CREATION, 0, 0);
- write_recorder.Record(&recording_cb1, REGISTRATION, write_fd,
- EPOLLOUT | O_NONBLOCK);
- write_recorder.Record(&recording_cb1, UNREGISTRATION, write_fd, false);
- write_recorder.Record(&recording_cb1, SHUTDOWN, write_fd, 0);
- EXPECT_TRUE(recorder1->IsEqual(&write_recorder));
-
- Recorder read_recorder;
- read_recorder.Record(&recording_cb2, CREATION, 0, 0);
- read_recorder.Record(&recording_cb2, REGISTRATION, read_fd,
- EPOLLIN | O_NONBLOCK);
- read_recorder.Record(&recording_cb2, UNREGISTRATION, read_fd, false);
- read_recorder.Record(&recording_cb2, SHUTDOWN, read_fd, 0);
- EXPECT_TRUE(recorder2->IsEqual(&read_recorder));
-
- close(read_fd);
- close(write_fd);
-}
-
-class UnregisterCB : public EpollCallbackInterface {
- public:
- explicit UnregisterCB(int fd)
- : eps_(nullptr), fd_(fd), onshutdown_called_(false) {}
-
- ~UnregisterCB() override {}
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int fd) override {
- eps_->UnregisterFD(fd_);
- eps_->UnregisterFD(fd);
- onshutdown_called_ = true;
- eps_ = nullptr;
- }
-
- void set_epollserver(SimpleEpollServer* eps) { eps_ = eps; }
- bool onshutdown_called() { return onshutdown_called_; }
-
- void OnRegistration(SimpleEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int /*fd*/, EpollEvent* /*event*/) override {}
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
-
- std::string Name() const override { return "UnregisterCB"; }
-
- protected:
- SimpleEpollServer* eps_;
- int fd_;
- bool onshutdown_called_;
-};
-
-// Check that unregistering fds in OnShutdown works cleanly.
-TEST(SimpleEpollServerTest, TestUnregisteringFDsOnShutdown) {
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
- int read_fd = pipe_fds[0];
- int write_fd = pipe_fds[1];
-
- UnregisterCB unreg_cb1(read_fd);
- UnregisterCB unreg_cb2(write_fd);
-
- {
- SimpleEpollServer ep;
- ep.set_timeout_in_us(1);
-
- unreg_cb1.set_epollserver(&ep);
- unreg_cb2.set_epollserver(&ep);
-
- // Register to listen to write events.
- ep.RegisterFD(write_fd, &unreg_cb1, EPOLLOUT | O_NONBLOCK);
- ep.RegisterFD(read_fd, &unreg_cb2, EPOLLIN | O_NONBLOCK);
- }
-
- // Make sure at least one onshutdown was called.
- EXPECT_TRUE(unreg_cb1.onshutdown_called() || unreg_cb2.onshutdown_called());
- // Make sure that both onshutdowns were not called.
- EXPECT_TRUE(
- !(unreg_cb1.onshutdown_called() && unreg_cb2.onshutdown_called()));
-
- close(read_fd);
- close(write_fd);
-}
-
-TEST(SimpleEpollServerTest, TestFDsAndAlarms) {
- SimpleEpollServer ep;
- ep.set_timeout_in_us(5);
- char data = 'x';
-
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
-
- RecordingCB recording_cb;
- const Recorder* recorder = recording_cb.recorder();
- const std::vector<RecordEntry>* records = recorder->records();
-
- TestAlarm alarm;
-
- ep.RegisterFDForRead(pipe_fds[0], &recording_cb);
-
- EXPECT_EQ(2u, records->size());
- EXPECT_FALSE(alarm.was_called());
-
- // Write to the pipe and set a longish alarm so we get a read event followed
- // by an alarm event.
- int written = write(pipe_fds[1], &data, 1);
- EXPECT_EQ(1, written);
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(3u, records->size());
- EXPECT_FALSE(alarm.was_called());
- ep.RegisterAlarm(WallTimeNowInUsec() + 1000, &alarm);
- WaitForAlarm(&ep, alarm);
- EXPECT_EQ(3u, records->size());
- EXPECT_TRUE(alarm.was_called());
- alarm.Reset();
-
- // Now set a short alarm so the alarm and the read event are called together.
- ep.RegisterAlarm(WallTimeNowInUsec(), &alarm);
- written = write(pipe_fds[1], &data, 1);
- EXPECT_EQ(1, written);
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_TRUE(alarm.was_called());
- EXPECT_EQ(4u, records->size());
-
- ep.UnregisterFD(pipe_fds[0]);
-
- close(pipe_fds[0]);
- close(pipe_fds[1]);
-}
-
-class EpollReader : public EpollCallbackInterface {
- public:
- explicit EpollReader(int len)
- : len_(0), expected_len_(len), done_reading_(false) {
- memset(&buf_, 0, kMaxBufLen);
- }
-
- ~EpollReader() override {}
-
- void OnRegistration(SimpleEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
-
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
-
- void OnEvent(int fd, EpollEvent* event) override {
- if (event->in_events & EPOLLIN) {
- len_ += read(fd, &buf_ + len_, kMaxBufLen - len_);
- }
-
- // If we have finished reading...
- if (event->in_events & EPOLLHUP) {
- CHECK_EQ(len_, expected_len_);
- done_reading_ = true;
- }
- }
-
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {
- // None of the current tests involve having active callbacks when the
- // server shuts down.
- EPOLL_LOG(FATAL);
- }
-
- std::string Name() const override { return "EpollReader"; }
-
- // Returns true if the data in buf is the same as buf_, false otherwise.
- bool CheckOutput(char* buf, int len) {
- if (len != len_) {
- return false;
- }
- return !memcmp(buf, buf_, len);
- }
-
- bool done_reading() { return done_reading_; }
-
- protected:
- int len_;
- int expected_len_;
- char buf_[kMaxBufLen];
- bool done_reading_;
-};
-
-void TestPipe(char* test_message, int len) {
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe failed()";
- }
- int reader_pipe = pipe_fds[0];
- int writer_pipe = pipe_fds[1];
- int child_pid;
- memset(test_message, 'x', len);
-
- switch (child_pid = fork()) {
- case 0: { // Child will send message.
- const char* message = test_message;
- int size;
- close(reader_pipe);
- while ((size = write(writer_pipe, message, len)) > 0) {
- message += size;
- len -= size;
- if (len == 0) {
- break;
- }
- }
- if (len > 0) {
- EPOLL_PLOG(FATAL) << "write() failed";
- }
- close(writer_pipe);
-
- _exit(0);
- }
- case -1:
- EPOLL_PLOG(FATAL) << "fork() failed";
- break;
- default: { // Parent will receive message.
- close(writer_pipe);
- auto ep = std::make_unique<SimpleEpollServer>();
- ep->set_timeout_in_us(1);
- EpollReader reader(len);
- ep->RegisterFD(reader_pipe, &reader, EPOLLIN);
-
- int64_t start_ms = WallTimeNowInUsec() / 1000;
- // Loop until we're either done reading, or have waited ~10 us.
- while (!reader.done_reading() &&
- (WallTimeNowInUsec() / 1000 - start_ms) < 10000) {
- ep->WaitForEventsAndExecuteCallbacks();
- }
- ep->UnregisterFD(reader_pipe);
- CHECK(reader.CheckOutput(test_message, len));
- break;
- }
- }
-
- close(reader_pipe);
- close(writer_pipe);
-}
-
-TEST(SimpleEpollServerTest, TestSmallPipe) {
- char buf[kMaxBufLen];
- TestPipe(buf, 10);
-}
-
-TEST(SimpleEpollServerTest, TestLargePipe) {
- char buf[kMaxBufLen];
- TestPipe(buf, kMaxBufLen);
-}
-
-// Tests RegisterFDForRead as well as StopRead.
-TEST(SimpleEpollServerTest, TestRead) {
- SimpleEpollServer ep;
- ep.set_timeout_in_us(1);
- int len = 1;
-
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
- int read_fd = pipe_fds[0];
- int write_fd = pipe_fds[1];
-
- auto reader = std::make_unique<EpollReader>(len);
-
- // Check that registering a FD for read alerts us when there is data to be
- // read.
- ep.RegisterFDForRead(read_fd, reader.get());
- char data = 'a';
- int size = write(write_fd, &data, 1);
- EXPECT_EQ(1, size);
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_TRUE(reader->CheckOutput(&data, len));
-
- // Remove the callback for read events, write to the pipe and make sure that
- // we did not read more data.
- ep.StopRead(read_fd);
- size = write(write_fd, &data, len);
- EXPECT_EQ(1, size);
- // The wait will return after timeout.
- ep.WaitForEventsAndExecuteCallbacks();
- EXPECT_TRUE(reader->CheckOutput(&data, len));
- ep.UnregisterFD(read_fd);
-
- close(read_fd);
- close(write_fd);
-}
-
-class EdgeTriggerCB : public EpollCallbackInterface {
- public:
- EdgeTriggerCB(int read_size, int write_size, char write_char, char peer_char)
- : eps_(nullptr),
- read_buf_(read_size),
- write_buf_(write_size, write_char),
- peer_char_(peer_char) {
- Reset();
- }
-
- ~EdgeTriggerCB() override {}
-
- void Reset() {
- CHECK(eps_ == nullptr);
- bytes_read_ = 0;
- bytes_written_ = 0;
- can_read_ = false;
- will_read_ = false;
- can_write_ = false;
- will_write_ = false;
- read_closed_ = false;
- write_closed_ = false;
- }
-
- void ResetByteCounts() { bytes_read_ = bytes_written_ = 0; }
-
- void set_will_read(bool will_read) { will_read_ = will_read; }
-
- void set_will_write(bool will_write) { will_write_ = will_write; }
-
- bool can_write() const { return can_write_; }
-
- int bytes_read() const { return bytes_read_; }
-
- int bytes_written() const { return bytes_written_; }
-
- void OnRegistration(SimpleEpollServer* eps, int fd, int event_mask) override {
- EXPECT_TRUE(eps_ == nullptr);
- eps_ = eps;
- Initialize(fd, event_mask);
- }
-
- void OnModification(int fd, int event_mask) override {
- EXPECT_TRUE(eps_ != nullptr);
- if (event_mask & EPOLLET) {
- Initialize(fd, event_mask);
- } else {
- eps_->SetFDNotReady(fd);
- }
- }
-
- void OnEvent(int fd, EpollEvent* event) override {
- const int event_mask = event->in_events;
- if (event_mask & (EPOLLHUP | EPOLLERR)) {
- write_closed_ = true;
- return;
- }
- if (will_read_ && event_mask & EPOLLIN) {
- EXPECT_FALSE(read_closed_);
- int read_size = read_buf_.size();
- memset(&read_buf_[0], 0, read_size);
- int len = recv(fd, &read_buf_[0], read_size, MSG_DONTWAIT);
- // Update the readiness states
- can_read_ = (len == read_size);
-
- if (len > 0) {
- bytes_read_ += len;
- EPOLL_VLOG(1) << "fd: " << fd << ", read " << len
- << ", total: " << bytes_read_;
- // Now check the bytes read
- EXPECT_TRUE(CheckReadBuffer(len));
- } else if (len < 0) {
- EPOLL_VLOG(1) << "fd: " << fd << " read hit EAGAIN";
- EXPECT_EQ(EAGAIN, errno) << strerror(errno);
- can_read_ = false;
- } else {
- read_closed_ = true;
- }
- }
- if (will_write_ && event_mask & EPOLLOUT) {
- // Write side close/full close can only detected by EPOLLHUP, which is
- // caused by EPIPE.
- EXPECT_FALSE(write_closed_);
- int write_size = write_buf_.size();
- int len = send(fd, &write_buf_[0], write_size, MSG_DONTWAIT);
- can_write_ = (len == write_size);
- if (len > 0) {
- bytes_written_ += len;
- EPOLL_VLOG(1) << "fd: " << fd << ", write " << len
- << ", total: " << bytes_written_;
- } else {
- EPOLL_VLOG(1) << "fd: " << fd << " write hit EAGAIN";
- EXPECT_EQ(EAGAIN, errno) << strerror(errno);
- can_write_ = false;
- }
- }
- // Since we can only get on the ready list once, wait till we confirm both
- // read and write side continuation state and set the correct event mask
- // for the ready list.
- event->out_ready_mask = can_read_ ? static_cast<int>(EPOLLIN) : 0;
- if (can_write_) {
- event->out_ready_mask |= EPOLLOUT;
- }
- }
-
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {
- EXPECT_TRUE(eps_ != nullptr);
- eps_ = nullptr;
- }
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {
- // None of the current tests involve having active callbacks when the
- // server shuts down.
- EPOLL_LOG(FATAL);
- }
-
- std::string Name() const override { return "EdgeTriggerCB"; }
-
- private:
- SimpleEpollServer* eps_;
- std::vector<char> read_buf_;
- int bytes_read_;
- std::vector<char> write_buf_;
- int bytes_written_;
- char peer_char_; // The char we expected to read.
- bool can_read_;
- bool will_read_;
- bool can_write_;
- bool will_write_;
- bool read_closed_;
- bool write_closed_;
-
- void Initialize(int fd, int event_mask) {
- CHECK(eps_);
- can_read_ = can_write_ = false;
- if (event_mask & EPOLLET) {
- int events = 0;
- if (event_mask & EPOLLIN) {
- events |= EPOLLIN;
- can_read_ = true;
- }
- if (event_mask & EPOLLOUT) {
- events |= EPOLLOUT;
- can_write_ = true;
- }
- eps_->SetFDReady(fd, events);
- }
- }
-
- bool CheckReadBuffer(int len) const {
- for (int i = 0; i < len; ++i) {
- if (peer_char_ != read_buf_[i]) {
- return false;
- }
- }
- return true;
- }
-};
-
-// Test adding and removing from the ready list.
-TEST(SimpleEpollServerTest, TestReadyList) {
- SimpleEpollServer ep;
- int pipe_fds[2];
- if (pipe(pipe_fds) < 0) {
- EPOLL_PLOG(FATAL) << "pipe() failed";
- }
-
- // Just use any CB will do, since we never wait on epoll events.
- EdgeTriggerCB reader1(0, 0, 0, 0);
- EdgeTriggerCB reader2(0, 0, 0, 0);
-
- ep.RegisterFD(pipe_fds[0], &reader1, EPOLLIN);
- ep.RegisterFD(pipe_fds[1], &reader2, EPOLLOUT);
-
- // Adding fds that are registered with eps
- EXPECT_FALSE(ep.IsFDReady(pipe_fds[0]));
- EXPECT_FALSE(ep.IsFDReady(pipe_fds[1]));
-
- ep.SetFDReady(pipe_fds[0], EPOLLIN);
- EXPECT_TRUE(ep.IsFDReady(pipe_fds[0]));
- EXPECT_FALSE(ep.IsFDReady(pipe_fds[1]));
- EXPECT_EQ(1u, ep.ReadyListSize());
- ep.SetFDReady(pipe_fds[1], EPOLLOUT);
- EXPECT_TRUE(ep.IsFDReady(pipe_fds[0]));
- EXPECT_TRUE(ep.IsFDReady(pipe_fds[1]));
- EXPECT_EQ(2u, ep.ReadyListSize());
-
- // Now check that SetFDNotReady doesn't affect other fds
- ep.SetFDNotReady(pipe_fds[0]);
- EXPECT_FALSE(ep.IsFDReady(pipe_fds[0]));
- EXPECT_TRUE(ep.IsFDReady(pipe_fds[1]));
- EXPECT_EQ(1u, ep.ReadyListSize());
-
- ep.UnregisterFD(pipe_fds[0]);
- ep.UnregisterFD(pipe_fds[1]);
- EXPECT_EQ(0u, ep.ReadyListSize());
-
- // Now try adding them when they are not registered, and it shouldn't work.
- ep.SetFDReady(pipe_fds[0], EPOLLIN);
- EXPECT_FALSE(ep.IsFDReady(pipe_fds[0]));
- EXPECT_EQ(0u, ep.ReadyListSize());
-
- close(pipe_fds[0]);
- close(pipe_fds[1]);
-}
-
-class EPSWaitThread : public EpollThread {
- public:
- explicit EPSWaitThread(SimpleEpollServer* eps)
- : EpollThread("EPSWait"), eps_(eps), done_(false) {}
-
- void Run() override { eps_->WaitForEventsAndExecuteCallbacks(); }
-
- bool done() { return done_; }
-
- private:
- SimpleEpollServer* eps_;
- bool done_;
-};
-
-TEST(EpollServerTest, TestWake) {
- SimpleEpollServer eps;
- eps.set_timeout_in_us(-1);
- EPSWaitThread eps_thread(&eps);
- eps_thread.Start();
-
- EXPECT_FALSE(eps_thread.done());
- eps.Wake();
- eps_thread.Join();
-}
-
-class UnRegisterWhileProcessingCB : public EpollCallbackInterface {
- public:
- explicit UnRegisterWhileProcessingCB(int fd) : eps_(nullptr), fd_(fd) {}
-
- ~UnRegisterWhileProcessingCB() override {}
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {}
-
- void set_epoll_server(SimpleEpollServer* eps) { eps_ = eps; }
- void OnRegistration(SimpleEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int /*fd*/, EpollEvent* /*event*/) override {
- // This should cause no problems.
- eps_->UnregisterFD(fd_);
- }
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
- std::string Name() const override { return "UnRegisterWhileProcessingCB"; }
-
- protected:
- SimpleEpollServer* eps_;
- int fd_;
-};
-
-class RegisterWhileProcessingCB : public EpollCallbackInterface {
- public:
- RegisterWhileProcessingCB(int fd, EpollCallbackInterface* cb)
- : eps_(nullptr), fd_(fd), cb_(cb) {}
-
- ~RegisterWhileProcessingCB() override {}
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {}
-
- void set_epoll_server(SimpleEpollServer* eps) { eps_ = eps; }
- void OnRegistration(SimpleEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int /*fd*/, EpollEvent* /*event*/) override {
- // This should cause no problems.
- eps_->RegisterFDForReadWrite(fd_, cb_);
- }
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
- std::string Name() const override { return "RegisterWhileProcessingCB"; }
-
- protected:
- SimpleEpollServer* eps_;
- int fd_;
- EpollCallbackInterface* cb_;
-};
-
-// Nothing bad should happen when we do this. We're -only-
-// testing that nothing bad occurs in this test.
-TEST(SimpleEpollServerTest, NothingBadWhenUnRegisteringFDWhileProcessingIt) {
- UnRegisterWhileProcessingCB cb(0);
- {
- FakeSimpleEpollServer epoll_server;
- cb.set_epoll_server(&epoll_server);
- epoll_server.RegisterFDForReadWrite(0, &cb);
- epoll_event ee;
- ee.data.fd = 0;
- epoll_server.AddEvent(0, ee);
- epoll_server.AdvanceBy(1);
- epoll_server.WaitForEventsAndExecuteCallbacks();
- }
-}
-
-//
-// testing that nothing bad occurs in this test.
-TEST(SimpleEpollServerTest,
- NoEventsDeliveredForFdsOfUnregisteredCBsWithReRegdFD) {
- // events: fd0, fd1, fd2
- // fd0 -> unreg fd2
- // fd1 -> reg fd2
- // fd2 -> no event should be seen
- RecordingCB recorder_cb;
- UnRegisterWhileProcessingCB unreg_cb(-3);
- RegisterWhileProcessingCB reg_other_cb(-3, &recorder_cb);
- {
- FakeSimpleEpollServer epoll_server;
- unreg_cb.set_epoll_server(&epoll_server);
- reg_other_cb.set_epoll_server(&epoll_server);
- epoll_server.RegisterFDForReadWrite(-1, &unreg_cb);
- epoll_server.RegisterFDForReadWrite(-2, ®_other_cb);
- epoll_server.RegisterFDForReadWrite(-3, &recorder_cb);
-
- epoll_event ee;
- ee.events = EPOLLIN; // asserted for all events for this test.
-
- // Note that these events are in 'backwards' order in terms of time.
- // Currently, the SimpleEpollServer code invokes the CBs from last delivered
- // to first delivered, so this is to be sure that we invoke the CB for -1
- // before -2, before -3.
- ee.data.fd = -1;
- epoll_server.AddEvent(2, ee);
- ee.data.fd = -2;
- epoll_server.AddEvent(1, ee);
- ee.data.fd = -3;
- epoll_server.AddEvent(0, ee);
-
- epoll_server.AdvanceBy(5);
- epoll_server.WaitForEventsAndExecuteCallbacks();
- }
-
- Recorder correct_recorder;
- correct_recorder.Record(&recorder_cb, CREATION, 0, 0);
- correct_recorder.Record(&recorder_cb, REGISTRATION, -3, EPOLLIN | EPOLLOUT);
- correct_recorder.Record(&recorder_cb, UNREGISTRATION, -3, 0);
- correct_recorder.Record(&recorder_cb, REGISTRATION, -3, EPOLLIN | EPOLLOUT);
- correct_recorder.Record(&recorder_cb, SHUTDOWN, -3, 0);
-
- EXPECT_TRUE(correct_recorder.IsEqual(recorder_cb.recorder()));
-}
-
-class ReRegWhileReadyListOnEvent : public EpollCallbackInterface {
- public:
- explicit ReRegWhileReadyListOnEvent(int /*fd*/) : eps_(nullptr) {}
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {}
-
- void set_epoll_server(SimpleEpollServer* eps) { eps_ = eps; }
- void OnRegistration(SimpleEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int fd, EpollEvent* /*event_mask*/) override {
- // This should cause no problems.
- eps_->UnregisterFD(fd);
- eps_->RegisterFDForReadWrite(fd, this);
- eps_->UnregisterFD(fd);
- }
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
- std::string Name() const override { return "ReRegWhileReadyListOnEvent"; }
-
- protected:
- SimpleEpollServer* eps_;
-};
-
-// Nothing bad should happen when we do this. We're -only-
-// testing that nothing bad occurs in this test.
-TEST(SimpleEpollServerTest,
- NothingBadWhenReRegisteringFDWhileProcessingFromReadyList) {
- ReRegWhileReadyListOnEvent cb(0);
- {
- FakeSimpleEpollServer epoll_server;
- cb.set_epoll_server(&epoll_server);
- epoll_server.RegisterFDForReadWrite(0, &cb);
- epoll_event ee;
- ee.data.fd = 0;
- epoll_server.AddEvent(0, ee);
- epoll_server.AdvanceBy(1);
- epoll_server.WaitForEventsAndExecuteCallbacks();
- }
-}
-
-class UnRegEverythingReadyListOnEvent : public EpollCallbackInterface {
- public:
- UnRegEverythingReadyListOnEvent() : eps_(nullptr), fd_(0), fd_range_(0) {}
-
- void set_fd(int fd) { fd_ = fd; }
- void set_fd_range(int fd_range) { fd_range_ = fd_range; }
- void set_num_called(int* num_called) { num_called_ = num_called; }
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {}
-
- void set_epoll_server(SimpleEpollServer* eps) { eps_ = eps; }
- void OnRegistration(SimpleEpollServer* eps, int fd,
- int /*event_mask*/) override {
- eps->SetFDReady(fd, EPOLLIN);
- }
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int /*fd*/, EpollEvent* /*event*/) override {
- // This should cause no problems.
- CHECK(num_called_ != nullptr);
- ++(*num_called_);
- // Note that we're iterating from -fd_range + 1 -> 0.
- // We do this because there is an FD installed into the
- // epollserver somewhere in the low numbers.
- // Using negative FD numbers (which are guaranteed to not
- // exist in the epoll-server) ensures that we will not
- // come in conflict with the preexisting FD.
- for (int i = -fd_range_ + 1; i <= 0; ++i) {
- eps_->UnregisterFD(i);
- }
- }
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
- std::string Name() const override {
- return "UnRegEverythingReadyListOnEvent";
- }
-
- protected:
- SimpleEpollServer* eps_;
- int fd_;
- int fd_range_;
- int* num_called_;
-};
-
-TEST(SimpleEpollServerTest,
- NothingBadWhenUnRegisteredWhileProcessingFromReadyList) {
- const size_t kNumCallbacks = 32u;
- UnRegEverythingReadyListOnEvent callbacks[kNumCallbacks];
- int num_called = 0;
- {
- FakeSimpleEpollServer epoll_server;
- for (size_t i = 0; i < kNumCallbacks; ++i) {
- callbacks[i].set_fd(-i);
- callbacks[i].set_fd_range(kNumCallbacks);
- callbacks[i].set_num_called(&num_called);
- callbacks[i].set_epoll_server(&epoll_server);
- epoll_server.RegisterFDForReadWrite(0, &callbacks[i]);
- epoll_event ee;
- ee.data.fd = -i;
- epoll_server.AddEvent(0, ee);
- }
- epoll_server.AdvanceBy(1);
- epoll_server.WaitForEventsAndExecuteCallbacks();
- epoll_server.WaitForEventsAndExecuteCallbacks();
- }
- EXPECT_EQ(1, num_called);
-}
-
-TEST(SimpleEpollServerTest, TestThatVerifyReadyListWorksWithNothingInList) {
- FakeSimpleEpollServer epoll_server;
- epoll_server.VerifyReadyList();
-}
-
-TEST(SimpleEpollServerTest, TestThatVerifyReadyListWorksWithStuffInLists) {
- FakeSimpleEpollServer epoll_server;
- epoll_server.VerifyReadyList();
-}
-
-TEST(SimpleEpollServerTest,
- ApproximateNowInUsAccurateOutideOfWaitForEventsAndExecuteCallbacks) {
- FakeSimpleEpollServer epoll_server;
- epoll_server.AdvanceBy(1232);
- EXPECT_EQ(epoll_server.ApproximateNowInUsec(), epoll_server.NowInUsec());
- epoll_server.AdvanceBy(1111);
- EXPECT_EQ(epoll_server.ApproximateNowInUsec(), epoll_server.NowInUsec());
-}
-
-class ApproximateNowInUsecTestCB : public EpollCallbackInterface {
- public:
- ApproximateNowInUsecTestCB() : feps_(nullptr), called_(false) {}
-
- void OnRegistration(SimpleEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int /*fd*/, EpollEvent* /*event*/) override {
- EXPECT_EQ(feps_->ApproximateNowInUsec(), feps_->NowInUsec());
- feps_->AdvanceBy(1111);
- EXPECT_EQ(1 * 1111 + feps_->ApproximateNowInUsec(), feps_->NowInUsec());
- feps_->AdvanceBy(1111);
- EXPECT_EQ(2 * 1111 + feps_->ApproximateNowInUsec(), feps_->NowInUsec());
- called_ = true;
- }
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {}
- std::string Name() const override { return "ApproximateNowInUsecTestCB"; }
-
- void set_fakeepollserver(FakeSimpleEpollServer* feps) { feps_ = feps; }
- bool called() const { return called_; }
-
- protected:
- FakeSimpleEpollServer* feps_;
- bool called_;
-};
-
-TEST(SimpleEpollServerTest,
- ApproximateNowInUsApproximateInsideOfWaitForEventsAndExecuteCallbacks) {
- int dummy_fd = 11111;
- ApproximateNowInUsecTestCB aniutcb;
- {
- FakeSimpleEpollServer epoll_server;
- aniutcb.set_fakeepollserver(&epoll_server);
-
- epoll_server.RegisterFD(dummy_fd, &aniutcb, EPOLLIN);
- epoll_event ee;
- ee.data.fd = dummy_fd;
- ee.events = EPOLLIN;
- epoll_server.AddEvent(10242, ee);
- epoll_server.set_timeout_in_us(-1);
- epoll_server.AdvanceByAndWaitForEventsAndExecuteCallbacks(20000);
- EXPECT_TRUE(aniutcb.called());
- }
-}
-
-// A mock epoll server that also simulates kernel delay in scheduling epoll
-// events.
-class FakeEpollServerWithDelay : public FakeSimpleEpollServer {
- public:
- FakeEpollServerWithDelay() : FakeSimpleEpollServer(), delay(0) {}
-
- int delay;
-
- protected:
- int epoll_wait_impl(int epfd, struct epoll_event* events, int max_events,
- int timeout_in_ms) override {
- int out = FakeSimpleEpollServer::epoll_wait_impl(epfd, events, max_events,
- timeout_in_ms);
- AdvanceBy(delay);
- return out;
- }
-};
-
-// A callback that records the epoll event's delay.
-class RecordDelayOnEvent : public EpollCallbackInterface {
- public:
- RecordDelayOnEvent() : last_delay(-1), eps_(nullptr) {}
-
- ~RecordDelayOnEvent() override {}
-
- void OnShutdown(SimpleEpollServer* /*eps*/, int /*fd*/) override {}
-
- std::string Name() const override { return "RecordDelayOnEvent"; }
-
- void set_epoll_server(SimpleEpollServer* eps) { eps_ = eps; }
- void OnRegistration(SimpleEpollServer* /*eps*/, int /*fd*/,
- int /*event_mask*/) override {}
- void OnModification(int /*fd*/, int /*event_mask*/) override {}
- void OnEvent(int /*fd*/, EpollEvent* /*event*/) override {
- last_delay = eps_->LastDelayInUsec();
- }
- void OnUnregistration(int /*fd*/, bool /*replaced*/) override {}
-
- int64_t last_delay;
-
- protected:
- SimpleEpollServer* eps_;
-};
-
-// Tests that an epoll callback sees the correct delay for its event when it
-// calls LastDelayInUsec().
-TEST(EpollServerTest, TestLastDelay) {
- RecordDelayOnEvent cb;
- FakeEpollServerWithDelay epoll_server;
-
- cb.set_epoll_server(&epoll_server);
-
- epoll_server.RegisterFDForReadWrite(0, &cb);
- epoll_event ee;
- ee.data.fd = 0;
-
- // Inject delay, and confirm that it's reported.
- epoll_server.set_timeout_in_us(5000);
- epoll_server.delay = 6000;
- epoll_server.AddEvent(0, ee);
- epoll_server.AdvanceBy(1);
- epoll_server.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(cb.last_delay, 1000);
-
- // Fire an event before the timeout ends, and confirm that reported delay
- // isn't negative.
- epoll_server.set_timeout_in_us(5000);
- epoll_server.delay = 0;
- epoll_server.AddEvent(0, ee);
- epoll_server.AdvanceBy(1);
- epoll_server.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(cb.last_delay, 0);
-
- // Wait forever until an event fires, and confirm there's no reported delay.
- epoll_server.set_timeout_in_us(-1);
- epoll_server.delay = 6000;
- epoll_server.AddEvent(0, ee);
- epoll_server.AdvanceBy(1);
- epoll_server.WaitForEventsAndExecuteCallbacks();
- EXPECT_EQ(cb.last_delay, 0);
-}
-
-TEST(SimpleEpollServerAlarmTest, TestShutdown) {
- std::unique_ptr<SimpleEpollServer> eps(new SimpleEpollServer);
- EpollAlarm alarm1;
- EpollAlarm alarm2;
-
- eps->RegisterAlarmApproximateDelta(10000000, &alarm1);
- eps->RegisterAlarmApproximateDelta(10000000, &alarm2);
-
- alarm2.UnregisterIfRegistered();
- EXPECT_FALSE(alarm2.registered());
- eps = nullptr;
-
- EXPECT_FALSE(alarm1.registered());
-}
-
-TEST(SimpleEpollServerAlarmTest, TestUnregister) {
- SimpleEpollServer eps;
- EpollAlarm alarm;
-
- eps.RegisterAlarmApproximateDelta(10000000, &alarm);
- EXPECT_TRUE(alarm.registered());
-
- alarm.UnregisterIfRegistered();
- EXPECT_FALSE(alarm.registered());
-
- alarm.UnregisterIfRegistered();
- EXPECT_FALSE(alarm.registered());
-}
-
-TEST(SimpleEpollServerAlarmTest, TestUnregisterOnDestruction) {
- EpollTestServer eps;
- std::unique_ptr<EpollAlarm> alarm(new EpollAlarm());
- EpollAlarm* alarm_ptr = alarm.get();
-
- eps.RegisterAlarmApproximateDelta(10000000, alarm.get());
- EXPECT_TRUE(eps.ContainsAlarm(alarm_ptr));
- alarm = nullptr;
- EXPECT_EQ(0u, eps.GetNumPendingAlarmsForTest());
-}
-
-TEST(SimpleEpollServerAlarmTest, TestUnregisterOnAlarm) {
- EpollTestServer eps;
- EpollAlarm alarm;
-
- eps.RegisterAlarmApproximateDelta(1, &alarm);
- EXPECT_TRUE(eps.ContainsAlarm(&alarm));
-
- while (alarm.registered()) {
- eps.WaitForEventsAndExecuteCallbacks();
- }
- EXPECT_FALSE(eps.ContainsAlarm(&alarm));
-}
-
-TEST(SimpleEpollServerAlarmTest, TestReregisterAlarm) {
- EpollTestAlarms ep;
-
- EpollAlarm alarm;
- ep.set_time(1000);
- ep.RegisterAlarm(5000, &alarm);
-
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
- alarm.ReregisterAlarm(6000);
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
-
- ep.set_time(5000);
- ep.set_timeout_in_us(0);
- ep.CallAndReregisterAlarmEvents();
- EXPECT_EQ(1u, ep.GetNumPendingAlarmsForTest());
-
- ep.set_time(6000);
- ep.CallAndReregisterAlarmEvents();
- EXPECT_EQ(0u, ep.GetNumPendingAlarmsForTest());
-}
-
-TEST(SimpleEpollServerAlarmTest, TestThatSameAlarmCanNotBeRegisteredTwice) {
- TestAlarm alarm;
- SimpleEpollServer epoll_server;
- epoll_server.RegisterAlarm(1, &alarm);
- EXPECT_EPOLL_BUG(epoll_server.RegisterAlarm(1, &alarm),
- "Alarm already exists");
-}
-
-} // namespace
-
-} // namespace test
-
-} // namespace epoll_server
