| // Copyright 2012 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "base/message_loop/message_pump_libevent.h" | |
| #include <errno.h> | |
| #include <unistd.h> | |
| #include <memory> | |
| #include <utility> | |
| #include "base/auto_reset.h" | |
| #include "base/compiler_specific.h" | |
| #include "base/feature_list.h" | |
| #include "base/files/file_util.h" | |
| #include "base/logging.h" | |
| #include "base/notreached.h" | |
| #include "base/posix/eintr_wrapper.h" | |
| #include "base/time/time.h" | |
| #include "base/trace_event/base_tracing.h" | |
| #include "build/build_config.h" | |
| #include "third_party/libevent/event.h" | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| #include "base/message_loop/message_pump_epoll.h" | |
| #endif | |
| // Lifecycle of struct event | |
| // Libevent uses two main data structures: | |
| // struct event_base (of which there is one per message pump), and | |
| // struct event (of which there is roughly one per socket). | |
| // The socket's struct event is created in | |
| // MessagePumpLibevent::WatchFileDescriptor(), | |
| // is owned by the FdWatchController, and is destroyed in | |
| // StopWatchingFileDescriptor(). | |
| // It is moved into and out of lists in struct event_base by | |
| // the libevent functions event_add() and event_del(). | |
| namespace base { | |
| namespace { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| bool g_use_epoll = false; | |
| const Feature kMessagePumpEpoll{"MessagePumpEpoll", | |
| FEATURE_DISABLED_BY_DEFAULT}; | |
| #endif | |
| } // namespace | |
| MessagePumpLibevent::FdWatchController::FdWatchController( | |
| const Location& from_here) | |
| : FdWatchControllerInterface(from_here) {} | |
| MessagePumpLibevent::FdWatchController::~FdWatchController() { | |
| CHECK(StopWatchingFileDescriptor()); | |
| if (was_destroyed_) { | |
| DCHECK(!*was_destroyed_); | |
| *was_destroyed_ = true; | |
| } | |
| } | |
| bool MessagePumpLibevent::FdWatchController::StopWatchingFileDescriptor() { | |
| watcher_ = nullptr; | |
| std::unique_ptr<event> e = ReleaseEvent(); | |
| if (e) { | |
| // event_del() is a no-op if the event isn't active. | |
| int rv = event_del(e.get()); | |
| libevent_pump_ = nullptr; | |
| return (rv == 0); | |
| } | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| if (epoll_interest_ && epoll_pump_) { | |
| epoll_pump_->UnregisterInterest(epoll_interest_); | |
| epoll_interest_.reset(); | |
| epoll_pump_.reset(); | |
| } | |
| #endif | |
| return true; | |
| } | |
| void MessagePumpLibevent::FdWatchController::Init(std::unique_ptr<event> e) { | |
| DCHECK(e); | |
| DCHECK(!event_); | |
| event_ = std::move(e); | |
| } | |
| std::unique_ptr<event> MessagePumpLibevent::FdWatchController::ReleaseEvent() { | |
| return std::move(event_); | |
| } | |
| void MessagePumpLibevent::FdWatchController::OnFileCanReadWithoutBlocking( | |
| int fd, | |
| MessagePumpLibevent* pump) { | |
| // Since OnFileCanWriteWithoutBlocking() gets called first, it can stop | |
| // watching the file descriptor. | |
| if (!watcher_) | |
| return; | |
| watcher_->OnFileCanReadWithoutBlocking(fd); | |
| } | |
| void MessagePumpLibevent::FdWatchController::OnFileCanWriteWithoutBlocking( | |
| int fd, | |
| MessagePumpLibevent* pump) { | |
| DCHECK(watcher_); | |
| watcher_->OnFileCanWriteWithoutBlocking(fd); | |
| } | |
| const scoped_refptr<MessagePumpLibevent::EpollInterest>& | |
| MessagePumpLibevent::FdWatchController::AssignEpollInterest( | |
| const EpollInterestParams& params) { | |
| epoll_interest_ = MakeRefCounted<EpollInterest>(this, params); | |
| return epoll_interest_; | |
| } | |
| void MessagePumpLibevent::FdWatchController::OnFdReadable() { | |
| if (!watcher_) { | |
| // When a watcher is watching both read and write and both are possible, the | |
| // pump will call OnFdWritable() first, followed by OnFdReadable(). But | |
| // OnFdWritable() may stop or destroy the watch. If the watch is destroyed, | |
| // the pump will not call OnFdReadable() at all, but if it's merely stopped, | |
| // OnFdReadable() will be called while `watcher_` is null. In this case we | |
| // don't actually want to call the client. | |
| return; | |
| } | |
| watcher_->OnFileCanReadWithoutBlocking(epoll_interest_->params().fd); | |
| } | |
| void MessagePumpLibevent::FdWatchController::OnFdWritable() { | |
| DCHECK(watcher_); | |
| watcher_->OnFileCanWriteWithoutBlocking(epoll_interest_->params().fd); | |
| } | |
| MessagePumpLibevent::MessagePumpLibevent() { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| if (g_use_epoll) { | |
| epoll_pump_ = std::make_unique<MessagePumpEpoll>(); | |
| return; | |
| } | |
| #endif | |
| if (!Init()) | |
| NOTREACHED(); | |
| DCHECK_NE(wakeup_pipe_in_, -1); | |
| DCHECK_NE(wakeup_pipe_out_, -1); | |
| DCHECK(wakeup_event_); | |
| } | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| MessagePumpLibevent::MessagePumpLibevent(decltype(kUseEpoll)) | |
| : epoll_pump_(std::make_unique<MessagePumpEpoll>()) { | |
| epoll_pump_ = std::make_unique<MessagePumpEpoll>(); | |
| } | |
| #endif | |
| MessagePumpLibevent::~MessagePumpLibevent() { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| const bool using_libevent = !epoll_pump_; | |
| #else | |
| const bool using_libevent = true; | |
| #endif | |
| DCHECK(event_base_); | |
| if (using_libevent) { | |
| DCHECK(wakeup_event_); | |
| event_del(wakeup_event_.get()); | |
| wakeup_event_.reset(); | |
| if (wakeup_pipe_in_ >= 0) { | |
| if (IGNORE_EINTR(close(wakeup_pipe_in_)) < 0) | |
| DPLOG(ERROR) << "close"; | |
| } | |
| if (wakeup_pipe_out_ >= 0) { | |
| if (IGNORE_EINTR(close(wakeup_pipe_out_)) < 0) | |
| DPLOG(ERROR) << "close"; | |
| } | |
| } | |
| event_base_.reset(); | |
| } | |
| // Must be called early in process startup, but after FeatureList | |
| // initialization. This allows MessagePumpLibevent to query and cache the | |
| // enabled state of any relevant features. | |
| // static | |
| void MessagePumpLibevent::InitializeFeatures() { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| g_use_epoll = FeatureList::IsEnabled(kMessagePumpEpoll); | |
| #endif | |
| } | |
| bool MessagePumpLibevent::WatchFileDescriptor(int fd, | |
| bool persistent, | |
| int mode, | |
| FdWatchController* controller, | |
| FdWatcher* delegate) { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| if (epoll_pump_) { | |
| return epoll_pump_->WatchFileDescriptor(fd, persistent, mode, controller, | |
| delegate); | |
| } | |
| #endif | |
| TRACE_EVENT("base", "MessagePumpLibevent::WatchFileDescriptor", "fd", fd, | |
| "persistent", persistent, "watch_read", mode & WATCH_READ, | |
| "watch_write", mode & WATCH_WRITE); | |
| DCHECK_GE(fd, 0); | |
| DCHECK(controller); | |
| DCHECK(delegate); | |
| DCHECK(mode == WATCH_READ || mode == WATCH_WRITE || mode == WATCH_READ_WRITE); | |
| // WatchFileDescriptor should be called on the pump thread. It is not | |
| // threadsafe, and your watcher may never be registered. | |
| DCHECK(watch_file_descriptor_caller_checker_.CalledOnValidThread()); | |
| short event_mask = persistent ? EV_PERSIST : 0; | |
| if (mode & WATCH_READ) { | |
| event_mask |= EV_READ; | |
| } | |
| if (mode & WATCH_WRITE) { | |
| event_mask |= EV_WRITE; | |
| } | |
| std::unique_ptr<event> evt(controller->ReleaseEvent()); | |
| if (!evt) { | |
| // Ownership is transferred to the controller. | |
| evt = std::make_unique<event>(); | |
| } else { | |
| // Make sure we don't pick up any funky internal libevent masks. | |
| int old_interest_mask = evt->ev_events & (EV_READ | EV_WRITE | EV_PERSIST); | |
| // Combine old/new event masks. | |
| event_mask |= old_interest_mask; | |
| // Must disarm the event before we can reuse it. | |
| event_del(evt.get()); | |
| // It's illegal to use this function to listen on 2 separate fds with the | |
| // same |controller|. | |
| if (EVENT_FD(evt.get()) != fd) { | |
| NOTREACHED() << "FDs don't match" << EVENT_FD(evt.get()) << "!=" << fd; | |
| return false; | |
| } | |
| } | |
| // Set current interest mask and message pump for this event. | |
| event_set(evt.get(), fd, event_mask, OnLibeventNotification, controller); | |
| // Tell libevent which message pump this socket will belong to when we add it. | |
| if (event_base_set(event_base_.get(), evt.get())) { | |
| DPLOG(ERROR) << "event_base_set(fd=" << EVENT_FD(evt.get()) << ")"; | |
| return false; | |
| } | |
| // Add this socket to the list of monitored sockets. | |
| if (event_add(evt.get(), nullptr)) { | |
| DPLOG(ERROR) << "event_add failed(fd=" << EVENT_FD(evt.get()) << ")"; | |
| return false; | |
| } | |
| controller->Init(std::move(evt)); | |
| controller->set_watcher(delegate); | |
| controller->set_libevent_pump(this); | |
| return true; | |
| } | |
| // Tell libevent to break out of inner loop. | |
| static void timer_callback(int fd, short events, void* context) { | |
| event_base_loopbreak((struct event_base*)context); | |
| } | |
| // Reentrant! | |
| void MessagePumpLibevent::Run(Delegate* delegate) { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| if (epoll_pump_) { | |
| epoll_pump_->Run(delegate); | |
| return; | |
| } | |
| #endif | |
| RunState run_state(delegate); | |
| AutoReset<RunState*> auto_reset_run_state(&run_state_, &run_state); | |
| // event_base_loopexit() + EVLOOP_ONCE is leaky, see http://crbug.com/25641. | |
| // Instead, make our own timer and reuse it on each call to event_base_loop(). | |
| std::unique_ptr<event> timer_event(new event); | |
| for (;;) { | |
| // Do some work and see if the next task is ready right away. | |
| Delegate::NextWorkInfo next_work_info = delegate->DoWork(); | |
| bool immediate_work_available = next_work_info.is_immediate(); | |
| if (run_state.should_quit) | |
| break; | |
| // Process native events if any are ready. Do not block waiting for more. Do | |
| // not instantiate a ScopedDoWorkItem for this call as: | |
| // - This most often ends up calling OnLibeventNotification() below which | |
| // already instantiates a ScopedDoWorkItem (and doing so twice would | |
| // incorrectly appear as nested work). | |
| // - "ThreadController active" is already up per the above DoWork() so this | |
| // would only be about detecting #work-in-work-implies-nested | |
| // (ref. thread_controller.h). | |
| // - This can result in the same work as the | |
| // event_base_loop(event_base_, EVLOOP_ONCE) call at the end of this | |
| // method and that call definitely can't be in a ScopedDoWorkItem as | |
| // it includes sleep. | |
| // - The only downside is that, if a native work item other than | |
| // OnLibeventNotification() did enter a nested loop from here, it | |
| // wouldn't be labeled as such in tracing by "ThreadController active". | |
| // Contact gab@/scheduler-dev@ if a problematic trace emerges. | |
| event_base_loop(event_base_.get(), EVLOOP_NONBLOCK); | |
| bool attempt_more_work = immediate_work_available || processed_io_events_; | |
| processed_io_events_ = false; | |
| if (run_state.should_quit) | |
| break; | |
| if (attempt_more_work) | |
| continue; | |
| attempt_more_work = delegate->DoIdleWork(); | |
| if (run_state.should_quit) | |
| break; | |
| if (attempt_more_work) | |
| continue; | |
| bool did_set_timer = false; | |
| // If there is delayed work. | |
| DCHECK(!next_work_info.delayed_run_time.is_null()); | |
| if (!next_work_info.delayed_run_time.is_max()) { | |
| const TimeDelta delay = next_work_info.remaining_delay(); | |
| // Setup a timer to break out of the event loop at the right time. | |
| struct timeval poll_tv; | |
| poll_tv.tv_sec = static_cast<time_t>(delay.InSeconds()); | |
| poll_tv.tv_usec = delay.InMicroseconds() % Time::kMicrosecondsPerSecond; | |
| event_set(timer_event.get(), -1, 0, timer_callback, event_base_.get()); | |
| event_base_set(event_base_.get(), timer_event.get()); | |
| event_add(timer_event.get(), &poll_tv); | |
| did_set_timer = true; | |
| } | |
| // Block waiting for events and process all available upon waking up. This | |
| // is conditionally interrupted to look for more work if we are aware of a | |
| // delayed task that will need servicing. | |
| delegate->BeforeWait(); | |
| event_base_loop(event_base_.get(), EVLOOP_ONCE); | |
| // We previously setup a timer to break out the event loop to look for more | |
| // work. Now that we're here delete the event. | |
| if (did_set_timer) { | |
| event_del(timer_event.get()); | |
| } | |
| if (run_state.should_quit) | |
| break; | |
| } | |
| } | |
| void MessagePumpLibevent::Quit() { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| if (epoll_pump_) { | |
| epoll_pump_->Quit(); | |
| return; | |
| } | |
| #endif | |
| DCHECK(run_state_) << "Quit was called outside of Run!"; | |
| // Tell both libevent and Run that they should break out of their loops. | |
| run_state_->should_quit = true; | |
| ScheduleWork(); | |
| } | |
| void MessagePumpLibevent::ScheduleWork() { | |
| #if BUILDFLAG(ENABLE_MESSAGE_PUMP_EPOLL) | |
| if (epoll_pump_) { | |
| epoll_pump_->ScheduleWork(); | |
| return; | |
| } | |
| #endif | |
| // Tell libevent (in a threadsafe way) that it should break out of its loop. | |
| char buf = 0; | |
| long nwrite = HANDLE_EINTR(write(wakeup_pipe_in_, &buf, 1)); | |
| DPCHECK(nwrite == 1 || errno == EAGAIN) << "nwrite:" << nwrite; | |
| } | |
| void MessagePumpLibevent::ScheduleDelayedWork( | |
| const Delegate::NextWorkInfo& next_work_info) { | |
| // When using libevent we know that we can't be blocked on Run()'s | |
| // `timer_event` right now since this method can only be called on the same | |
| // thread as Run(). When using epoll, the pump clearly must be in between | |
| // waits if we're here. In either case, any scheduled work will be seen prior | |
| // to the next libevent loop or epoll wait, so there's nothing to do here. | |
| } | |
| bool MessagePumpLibevent::Init() { | |
| int fds[2]; | |
| if (!CreateLocalNonBlockingPipe(fds)) { | |
| DPLOG(ERROR) << "pipe creation failed"; | |
| return false; | |
| } | |
| wakeup_pipe_out_ = fds[0]; | |
| wakeup_pipe_in_ = fds[1]; | |
| wakeup_event_ = std::make_unique<event>(); | |
| event_set(wakeup_event_.get(), wakeup_pipe_out_, EV_READ | EV_PERSIST, | |
| OnWakeup, this); | |
| event_base_set(event_base_.get(), wakeup_event_.get()); | |
| if (event_add(wakeup_event_.get(), nullptr)) | |
| return false; | |
| return true; | |
| } | |
| // static | |
| void MessagePumpLibevent::OnLibeventNotification(int fd, | |
| short flags, | |
| void* context) { | |
| FdWatchController* controller = static_cast<FdWatchController*>(context); | |
| DCHECK(controller); | |
| MessagePumpLibevent* pump = controller->libevent_pump(); | |
| pump->processed_io_events_ = true; | |
| // Make the MessagePumpDelegate aware of this other form of "DoWork". Skip if | |
| // OnLibeventNotification is called outside of Run() (e.g. in unit tests). | |
| Delegate::ScopedDoWorkItem scoped_do_work_item; | |
| if (pump->run_state_) | |
| scoped_do_work_item = pump->run_state_->delegate->BeginWorkItem(); | |
| // Trace events must begin after the above BeginWorkItem() so that the | |
| // ensuing "ThreadController active" outscopes all the events under it. | |
| TRACE_EVENT("toplevel", "OnLibevent", "controller_created_from", | |
| controller->created_from_location(), "fd", fd, "flags", flags, | |
| "context", context); | |
| TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION heap_profiler_scope( | |
| controller->created_from_location().file_name()); | |
| if ((flags & (EV_READ | EV_WRITE)) == (EV_READ | EV_WRITE)) { | |
| // Both callbacks will be called. It is necessary to check that |controller| | |
| // is not destroyed. | |
| bool controller_was_destroyed = false; | |
| controller->was_destroyed_ = &controller_was_destroyed; | |
| controller->OnFileCanWriteWithoutBlocking(fd, pump); | |
| if (!controller_was_destroyed) | |
| controller->OnFileCanReadWithoutBlocking(fd, pump); | |
| if (!controller_was_destroyed) | |
| controller->was_destroyed_ = nullptr; | |
| } else if (flags & EV_WRITE) { | |
| controller->OnFileCanWriteWithoutBlocking(fd, pump); | |
| } else if (flags & EV_READ) { | |
| controller->OnFileCanReadWithoutBlocking(fd, pump); | |
| } | |
| } | |
| // Called if a byte is received on the wakeup pipe. | |
| // static | |
| void MessagePumpLibevent::OnWakeup(int socket, short flags, void* context) { | |
| TRACE_EVENT(TRACE_DISABLED_BY_DEFAULT("base"), | |
| "MessagePumpLibevent::OnWakeup", "socket", socket, "flags", flags, | |
| "context", context); | |
| MessagePumpLibevent* that = static_cast<MessagePumpLibevent*>(context); | |
| DCHECK(that->wakeup_pipe_out_ == socket); | |
| // Remove and discard the wakeup byte. | |
| char buf; | |
| long nread = HANDLE_EINTR(read(socket, &buf, 1)); | |
| DCHECK_EQ(nread, 1); | |
| that->processed_io_events_ = true; | |
| // Tell libevent to break out of inner loop. | |
| event_base_loopbreak(that->event_base_.get()); | |
| } | |
| MessagePumpLibevent::EpollInterest::EpollInterest( | |
| FdWatchController* controller, | |
| const EpollInterestParams& params) | |
| : controller_(controller), params_(params) {} | |
| MessagePumpLibevent::EpollInterest::~EpollInterest() = default; | |
| } // namespace base |